java流处理
Ⅰ java流的主要方法
Java的流操作分为字节流和字符流两种。
1、 字节流
所有的读操作都继承自一个公共超类java.io.InputStream类。
所有的写操作都继承自一个公共超类java.io.OutputStream类。
InputStream和OutputStream都是抽象类。
InputStream有6个低级输入流：
低级流
流的用途
ByteArrayInputStream
从内存数组中读取数据字节
FileInputStream
从本地文件系统中读取数据字节
PipedInputStream
从线程管道中读取数据字节
StringBufferInputStream
从字符串中读取数据字节
SequenceInputStream
从两个或多个低级流中读取数据字节，当到达流的末尾时从一个流转到另一个流
System.in
从用户控制台读取数据字节
InputStream还有一个子类：过滤器流java.io.FilterInputStream。过滤器流即能把基本流包裹起来，提供更多方便的用法。
FilterInputStream 类的构造方法为FilterInputStream(InputStream)，在指定的输入流之上，创建一个输入流过滤器。
过滤器输入流
流的用途
BufferedInputStream
缓冲区对数据的访问，以提高效率
DataInputStream
从输入流中读取基本数据类型，如int、float、double或者甚至一行文本
LineNumberInputStream
在翻译行结束符的基础上，维护一个计数器，该计数器表明正在读取的是哪一行。
PushbackInputStream
允许把数据字节向后推到流的首部
2、 字符流
注：是在jdk1.1里面引进的，上面字节流是在jdk1.0引进的。当用于处理文本数据时，选择字符流比字节流更好。但对只出路基本数据类型的开发者，可以继续使用字节流。
所有的读操作都继承自一个公共超类java.io.Reader类。
所有的写操作都继承自一个公共超类java.io.Writer类。
同样Reader和Writer也是抽象类。
Reader的常用的子类如下：
低级读取器
流的用途
CharArrayReader
从字符数组中读取数据
InputStreamReader
FileReader（InputStreamReader的子类）
从本地文件系统中读取字符序列
StringReader
从字符串中读取字符序列
PipedReader
从线程管道中读取字符序列
InputStreamReader重点讲解：
InputStreamReader是从输入流中读取数据，连接输入流于读取器。如：
new InputStreamReader(System.in)
构造方法：
InputStreamReader(InputStream)
用缺省的字符编码方式，创建一个 InputStreamReader。
InputStreamReader(InputStream, String) 用已命名的字符编码方式，创建一个 InputStreamReader。 常用的过滤器读取器：
过滤器读取器
流的用途
BufferedReader
缓冲数据的访问，以提高效率
LineNumberReader（BufferedReader的子类）
维护一个计数器，该计数器表明正在读取的是哪一行。
FilterReader（抽象类）
提供一个类创建过滤器时可以扩展这个类
PushbackReader（FilterReader的子类）
允许把文本数据推回到读取器的流中
这些过滤器读取器都可以传入一个Reader作为构造方法的参数。
Ⅱ java的流处理程序PrintStream编译不成功是怎么回事呢
你应该是没有导入java.util.Date这个类
Ⅲ java中高级流、低级流如何分
在输入输出里，有字节流和字符流分，这两者区别在于所操作的数据单元不同。还有另外一种认识，输入输出流可以分为节点刘和处理流（包装流），节点流有时候会被称为低级流，节点流是直接和实际的数据源相互连接的，和实际的输入输出点连接。处理流有时候也成为高级流，是对一个已存在的流进行连接或封装。区分节点流和处理流，只要看给出的参数是什么就行了，如果是一个实际的数据源，就是节点流，如果是一个流，就是处理流。如 x0dx0aPrintStream ps = new PrintStream(new FileOutputStream("out.txt"));x0dx0a在这里，FileOutputStream就是一个节点流，PrintStream就是一个处理流。x0dx0a至于说到，java里有哪些低级流，其实这个有很多，你可以看一下流的体系就行了。x0dx0aInputStream类中常用的低级流有InputStream、FileInputStream等，高级流有DataInputStream和BufferedInputStream，一般高级流要封装低级流，一般以read()方法读入。OutputStream类中常用的低级流有OutputStream、PipedOutputStream等，高级流有DataOutputStream和BufferedOutputStream，一般以Writer（）、Print()方法写入。字符流主要有Reader和Writer两种抽象类，Reader类中常用的低级流有FileReader等，高级流有BufferedReader、InputStreamReader等，以readLine()方法读一行字符。Writer类中常用的低级流有StringWriter、FileWriter等，高级流有BufferedWriter、PrintWriter等，以writer()和print()方法写入，如果用BufferedWriter时还要用flush()方法才能写入。
Ⅳ java中怎么识别节点流和处理流
按照流是否直接与特定的地方(如磁盘、内存、设备等)相连，分为节点流和处理流两类。
节点流：可以从或向一个特定的地方(节点)读写数据。如FileReader.
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
JAVA常用的节点流有以下几个：
文 件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
字符串 StringReader StringWriter 对字符串进行处理的节点流。
数 组 ByteArrayInputStream CharArrayWriter 对数组进行处理的节点流(对应的不再是文件，而是内存中的一个数组)。
管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
父 类 InputStream OutputStream Reader Writer
常用处理流(关闭处理流使用关闭里面的节点流)
缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter
增加缓冲功能，避免频繁读写硬盘。
转换流：InputStreamReader OutputStreamReader实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来。
Ⅳ Java中一个数据流处理的问题
对象序列化，把类的对象写入文件。虚拟机一关机对象就没了，对象序列化实现把对象从内存上存到硬盘上。如果对象很多，内存不够用,就可使对象序列化 。
输入输出流分别是ObjectInputStream和ObjectOutputSream:
如果类想要实现对象序列话必须实现 接口Serilizable.Serilizable接口中无任何方法。
下面给你个以前写的例子：
import java.io.Serializable;
public class Foo implements Serializable{
private String str;
private int value;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
public class TestOISOOS {
/**
* @param args
* @throws IOException
* @throws FileNotFoundException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File("7.txt")));
Foo foo=new Foo();
foo.setStr("foo");
foo.setValue(100);
//oos.writeObject(foo);
//oos.close();
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("7.txt")));
//Foo foo2=(Foo)ois.readObject();
//System.out.println(foo2.getStr());
//System.out.println(foo2.getValue());
ArrayList<Foo> fooList=new ArrayList<Foo>();
for(int i=0;i<10;i++){
Foo foo3=new Foo();
foo3.setStr(i+"a");
foo3.setValue(i+100);
fooList.add(foo3);
}
oos.writeObject(fooList);
oos.close();
fooList=(ArrayList<Foo>) ois.readObject();
for(int i=0;i<fooList.size();i++){
System.out.println(fooList.get(i).getStr());
System.out.println(fooList.get(i).getValue());
}
}
}
上面就是讲实例后的Foo对象写入到硬盘文件中。
Ⅵ 在java语言中处理数据基于流的形式，流有哪些分类形式
Java中的流从不同的角度可以分为以下几类：
1. 处理的数据单位不同，可分为：字符流，字节流
2.数据流方向不同，可分为：输入流，输出流
3.功能不同，可分为：节点流，处理流
Ⅶ Java字符流和字节流对文件操作的区别
Java字符流是处理字符（Char）对象用的，字节流是处理字节（Byte）对象用的。处理的目标对象不同，处理方法也就不一样了。
字符流处理的基本单位是字符（Java中的字符是16位的），输入流以Reader为基础，输出流以Writer为基础；
字节流的基本单位是字节（Java中的字节是8位的），输入流以 InputStream为基础，输出流以 OutputStream为基础；
字符流在输入时可以按字符读取，也可以按行读取，会去掉回车换行，常用于读取字符数据；
而字节流按字节读取，不作任何处理，常用于读取二进制数据。
Java中的字符在内部都是使用Unicode进行表示的，因此，要正确读取字符数据，需要知道字符的编码字符集，字符流提供编码字符集的指定，如果不指定使用系统默认的方式对字符数据进行编码转换，这个编码字符集不正确，会造成读进来的地字符出现乱码。
字节流虽然是读取二进制数据用的，但也可以读取字符文件，按字节进行处理，读进来之后可以根据编码字符集进行转换，也可以变成字符串。
Ⅷ java中的“流”是什么
Java中的流是个抽象的概念，当程序需要从某个数据源读入数据的时候，就会开启一个数据流，数据源可以是文件、内存或网络等等。相反地，需要写出数据到某个数据源目的地的时候，也会开启一个数据流，这个数据源目的地也可以是文件、内存或网络等等x0dx0ax0dx0aJava中的流可以从不同的角度进行分类：x0dx0a按照流的方向不同：分为输入流和输出流。x0dx0a按照处理数据单位的不同：分为字节流（8位）和字符流（16位）。x0dx0a按照功能不同：分为节点流和处理流。x0dx0a节点流：是可以从一个特定的数据源（节点）读写数据的流（例如文件，内存）。就像是一条单一的管子接到水龙头上开始放水。x0dx0a处理流：是“连接”在已经存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。就像在已经接了一条管子（节点流）的基础上，又套上几个更粗，具有特殊功能的管子（处理流）对流出的水进一步的处理。x0dx0a四种基本流InputStream，OutputStream，Reader，Writer又分别有更具体的子类，分为文件流，缓冲流，数据流，转换流，Print流，Object流等，都分别有特定的功能或用来操作特定的数据
Ⅸ java 中简述使用流进行读写文本文件的步骤
一、Java IO学习基础之读写文本文件
Java的IO操作都是基于流进行操作的，为了提高读写效率一般需要进行缓冲。
简单的示例程序如下：
/**
* 读出1.txt中的内容，写入2.txt中
*
*/
import java.io.*;
public class ReadWriteFile{
public static void main(String[] args){
try{
File read = new File("c:\\1.txt");
File write = new File("c:\\2.txt");
BufferedReader br = new BufferedReader(
new FileReader(read));
BufferedWriter bw = new BufferedWriter(
new FileWriter(write));
String temp = null;
temp = br.readLine();
while(temp != null){
//写文件
bw.write(temp + "\r\n"); //只适用Windows系统
//继续读文件
temp = br.readLine();
}
bw.close();
br.close();
}catch(FileNotFoundException e){ //文件未找到
System.out.println (e);
}catch(IOException e){
System.out.println (e);
}
}
}
以上是一个比较简单的基础示例。本文上下两部分都是从网上摘抄，合并在一起，方便下自己以后查找。
二、Java IO学习笔记+代码
文件对象的生成和文件的创建
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:10
*
* 文件对象的生成和文件的创建
*/
package study.iostudy;
import java.io.*;
public class GenerateFile
{
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject1 = new File("oneFirst.txt");
File fileObject2 = new File("d:\\mydir", "firstFile.txt");
System.out.println(fileObject2);
try
{
dirObject.mkdir();
}catch(SecurityException e)
{
e.printStackTrace();
}
try
{
fileObject2.createNewFile();
fileObject1.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
文件名的处理
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:29
*
* 文件名的处理
*/
package study.iostudy;
import java.io.*;
/*
* 文件名的处理
* String getName(); 获得文件的名称，不包含文件所在的路径。
* String getPath(); 获得文件的路径。
* String getAbsolutePath(); 获得文件的绝对路径。
* String getParent(); 获得文件的上一级目录的名称。
* String renameTo(File newName); 按参数中给定的完整路径更改当前的文件名。
* int compareTo(File pathName); 按照字典顺序比较两个文件对象的路径。
* boolean isAbsolute(); 测试文件对象的路径是不是绝对路径。
*/
public class ProcesserFileName
{
public static void main(String[] args)
{
File fileObject1 = new File("d:\\mydir\\firstFile.txt");
File fileObject2 = new File("d:\\firstFile.txt");
boolean pathAbsolute = fileObject1.isAbsolute();
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("There are some information of fileObject1's file name:");
System.out.println("fileObject1: " + fileObject1);
System.out.println("fileObject2: " + fileObject2);
System.out.println("file name: " + fileObject1.getName());
System.out.println("file path: " + fileObject1.getPath());
System.out.println("file absolute path: " + fileObject1.getAbsolutePath());
System.out.println("file's parent directory: " + fileObject1.getParent());
System.out.println("file's absoulte path: " + pathAbsolute);
int sameName = fileObject1.compareTo(fileObject2);
System.out.println("fileObject1 compare to fileObject2: " + sameName);
fileObject1.renameTo(fileObject2);
System.out.println("file's new name: " + fileObject1.getName());
}
}
测试和设置文件属性
/*
* SetterFileAttribute.java
*
* Created on 2006年8月22日, 下午3:51
*
* 测试和设置文件属性
*/
package study.iostudy;
import java.io.*;
public class SetterFileAttribute
{
/*
* File类中提供的有关文件属性测试方面的方法有以下几种：
* boolean exists(); 测试当前文件对象指示的文件是否存在。
* boolean isFile(); 测试当前文件对象是不是文件。
* boolean isDirectory(); 测试当前文件对象是不是目录。
* boolean canRead(); 测试当前文件对象是否可读。
* boolean canWrite(); 测试当前文件对象是否可写。
* boolean setReadOnly(); 将当前文件对象设置为只读。
* long length(); 获得当前文件对象的长度。
*/
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject = new File("d:\\mydir\\firstFile.txt");
try
{
dirObject.mkdir();
fileObject.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("there are some information about property of file object:");
System.out.println("file object : " + fileObject);
System.out.println("file exist? " + fileObject.exists());
System.out.println("Is a file? " + fileObject.isFile());
System.out.println("Is a directory?" + fileObject.isDirectory());
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
long fileLen = fileObject.length();
System.out.println("file length: " +fileLen);
boolean fileRead = fileObject.setReadOnly();
System.out.println(fileRead);
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
}
}
文件操作方法
/*
* FileOperation.java
*
* Created on 2006年8月22日, 下午4:25
*
* 文件操作方法
*/
package study.iostudy;
import java.io.*;
/*
* 有关文件操作方面的方法有如下几种:
* boolean createNewFile(); 根据当前的文件对象创建一个新的文件。
* boolean mkdir(); 根据当前的文件对象生成一目录，也就是指定路径下的文件夹。
* boolean mkdirs(); 也是根据当前的文件对象生成一个目录，
* 不同的地方在于该方法即使创建目录失败，
* 也会成功参数中指定的所有父目录。
* boolean delete(); 删除当前的文件。
* void deleteOnExit(); 当前Java虚拟机终止时删除当前的文件。
* String list(); 列出当前目录下的文件。
*/
public class FileOperation
* 找出一个目录下所有的文件
package study.iostudy;
import java.io.*;
public class SearchFile
{
public static void main(String[] args)
{
File dirObject = new File("D:\\aa");
Filter1 filterObj1 = new Filter1("HTML");
Filter2 filterObj2 = new Filter2("Applet");
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("list HTML files in directory: " + dirObject);
String[] filesObj1 = dirObject.list(filterObj1);
for (int i = 0; i < filesObj1.length; i++)
{
File fileObject = new File(dirObject, filesObj1[i]);
System.out.println(((fileObject.isFile())
? "HTML file: " : "sub directory: ") + fileObject);
}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
String[] filesObj2 = dirObject.list(filterObj2);
for (int i = 0; i < filesObj2.length; i++)
{
File fileObject = new File(dirObject, filesObj2[i]);
System.out.println(((fileObject.isFile())
? "htm file: " : "sub directory: ") + fileObject);
}
}
}
class Filter1 implements FilenameFilter
{
String fileExtent;
Filter1(String extentObj)
{
fileExtent = extentObj;
}
public boolean accept(File dir, String name)
{
return name.endsWith("." + fileExtent);
}
}
class Filter2 implements FilenameFilter
{
String fileName;
Filter2(String fileName)
{
this.fileName = fileName;
字符流处理
* ProcesserCharacterStream.java
* 字符流处理
*
* java.io包中加入了专门用于字符流处理的类，这些类都是Reader和Writer类的子类，
* Reader和Writer是两个抽象类，只提供了一系列用于字符流处理的接口，不能生成这
* 两个类的实例。
* java.io包中用于字符流处理的最基本的类是InputStreamReader和OutputStreamWriter，
* 用来在字节流和字符流之间作为中介。
*
* 下面是InputStreamReader类和OutputStreamWriter类的常用方法：
*
* public InputStreamReader(InputStream in)
* 根据当前平台缺省的编码规范，基于字节流in生成一个输入字符流。
* public InputStreamReader(InputStream in, String sysCode)throws UnSupportedEncodingException
* 按照参数sysCode指定的编码规范，基于字节流in构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。
* public OutputStreamWriter(OutputStream out)
* 根据当前平台缺省的编码规范，基于字节流out生成一个输入字符流。
* public OutputStreamWriter(OutputStream out, String sysCode) throws UnsupportedEncodingException
* 按照参数sysCode指定的编码规范，基于字节流out构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。
* public String getEncoding()
* 获得当前字符流使用的编码方式。
* public void close() throws IOException
* 用于关闭流。
* public int read() throws IOException
* 用于读取一个字符。
* public int read(char[] cbuf, int off, int len)
* 用于读取len个字符到数组cbuf的索引off处。
* public void write(char[] cbuf, int off, int len) throws IOException
* 将字符数组cbuf中从索引off处开始的len个字符写入输出流。
* public void write(int c) throws IOException
* 将单个字符写入输入流。
* public void write(String str, int off, int len) throws IOException
* 将字符串str中从索引off位置开始的ltn个字符写入输出流。
*
* 此外，为了提高字符流处理的效率，在Java语言中，引入了BufferedReader和BufferWriter类，这两个类对字符流进行块处理。
* 两个类的常用方法如下：
* public BufferedReader(Reader in)
* 用于基于普通字符输入流in生成相应的缓冲流。
* public BufferedReader(Reader in, int bufSize)
* 用于基于普通字符输入流in生成相应的缓冲流，缓冲区大小为参数bufSize指定。
* public BufferedWriter(Writer out)
* 用于基于普通字符输入流out生成相应的缓冲流。
* public BufferedWriter(Writer out, int bufSize)
* 用于基于普通字符输入流out生在相应缓冲流，缓冲流大小为参数bufSize指定。
* public String readLine() throws IOException
* 用于从输入流中读取一行字符。
* public void newLine() throws IOException
* 用于向字符输入流中写入一行结束标记，值得注意的是，该标记不是简单的换行符"\n"，而是系统定义的属性line.separator。
在上面的程序中，我们首先声明了FileInputStream类对象inStream和
* FileOutputStream类的对象outStream，接着声明了BufferInputStream
* 类对象bufObj、BufferedOutputStream类对象bufOutObj、
* DataInputStream类对象dataInObj以及PushbackInputStream类对象pushObj，
* 在try代码块中对上面这些对象进行初始化，程序的目的是通过BufferedInputStream
* 类对象bufInObj和BufferedOutputStream类对象bufOutObj将secondFile.txt
* 文件中内容输出到屏幕，并将该文件的内容写入thirdFile.txt文件中，值得注意的是，
* 将secondFile.txt文件中的内容输出之前，程序中使用
* "System.out.println(dataInObj.readBoolean());" 语句根据readBoolean()结果
* 输出了true，而secondFile.txt文件开始内容为“Modify”，和一个字符为M，
* 因此输出的文件内容没有“M”字符，thirdFile.txt文件中也比secondFile.txt
* 文件少第一个字符“M”。随后，通过PushbackInputStream类对象pushObj读取
* thirdFile.txt文件中的内容，输出读到的字符，当读到的不是字符，输出回车，将字符
* 数组pushByte写回到thirdFile.txt文件中，也就是“ok”写回文件中。
* 对象串行化
* 对象通过写出描述自己状态的数值来记录自己，这个过程叫做对象串行化。对象的寿命通
* 常是随着生成该对象的程序的终止而终止，在有些情况下，需要将对象的状态保存下来，然后
* 在必要的时候将对象恢复，值得注意的是，如果变量是另一个对象的引用，则引用的对象也要
* 串行化，串行化是一个递归的过程，可能会涉及到一个复杂树结构的串行化，比如包括原有对
* 象，对象的对象等。
* 在java.io包中，接口Serializable是实现对象串行化的工具,只有实现了Serializable
* 的对象才可以被串行化。Serializable接口中没有任何的方法，当一个类声明实现Seriali-
* zable接口时，只是表明该类遵循串行化协议，而不需要实现任何特殊的方法。
* 在进行对象串行化时，需要注意将串行化的对象和输入、输出流联系起来，首先通过对
* 象输出流将对象状态保存下来，然后通过对象输入流将对象状态恢复。