一、先看下必备知识：
1，流：系统内部和外部进行数据传输的管道。
2，内部：内存；外部：输入设备，文件，网络。
3，输入(读)通过输入流对象，从外把数据传送到内部。
4，输出(写)，从内到外，通过输出流对象，把内存数据传送到外部(网络，文件，显示器控制台)。
5，文本文件：
以ASCII码方式存放的文件，一般一个英文字符一个字节（以字节为单位），.txt某种意义上显示器和键盘也叫文本文件。
如果想看见文件的内容，这个文件必须以文本方式存放，所以显示器也是文本文件，与内存存放方式(二进制)unicode码不一样，将文件输入内存，使用需要转换。
缺点：文本文件如果处理需要转换，效率低
6，二进制文件：
以内存方式存放，内部怎么用外部怎么存，不可见，不能通过外部设备输入
优点：处理不需要转换，效率高，使用容易。
//***
流：严格意义上只有一种，就是字节流，jdk1.2版本增加了字符流，其实也是字节流的变体。
字节流传输太慢，又有过滤流(BufferedStream,DataStream,ObjectStream对象流)来套接，也叫套接流，假设字节流是个小管子，那么过滤流就是大管子，把大管子套接在小管子上，将字节流作为这些流的参数。另外，标准字节输入输出流(System.out/in/array)；还有管道流(PipedStream)，经常用于线程之间；顺序输入流(SequenceStream)，将小管子接在一起成为长管子，等等，这些也全是字节流，内存流很少使用。
二、常用流
1、字节流
字节流是一个抽象类，不是接口，因为输入字节流的read()方法没实现，输出字节流的write()方法没实现。不管是什么字节流，字节流的基类是inputStream OutputStream。
(1)inputStream 的一些常用方法:
对read做重载(三个)，
int read();//从输入流中读一个字节，形成一个0～255之间的整数返回（是一个抽象方法）。
int read(byte b[]);//从流中读取若干个字节的数据，存放到字节数组中，用于struts文件的上传
int read(byte b[],int off,int len);//从输入的字节流读取lenth个字节，从offset开始,放到字节数组中
close();//关闭
(2)OutputStream的一些常用方法:
对write做重载(三个)，
write(int b);//将一个整数最低字节数据输出到流中,
write(byte b[])//把内存的字节数组里的数据依次输出到流所指向的文件
write(byte b[],int off ,int length)//将数组b中从off指定的位置开始，长度为len的数据输出到流中;
flush();//刷空输出流，并将缓冲区中的数据强制送;一定要刷空。
close();//关闭
2、文件字节流
(1)文件字节流创建出输入流和输出流对象，
(2)文件输入和输出只作文本文件，以顺序操作，并且区分输入流和输出流。
例
import java.io.*;
class Filestream
{
public static void main(String args[])
{
try
{
File inFile=new File("file1.txt");
File outFile=new File("file2.txt");
//创建出输入流和输出流对象，
FileInputStream fis=new FileInputStream(inFile);
FileOutputStream fos=new FileOutputStream(outFile);
int c;
while((c=fis.read())!=-1) fos.write(c);
fis.close();//关闭
fos.close();
}catch(FileNotFoundException e) {
System.out.println("FileStreamsTest: "+e);
}catch(IOException e) {
System.err.println("FileStreamsTest: "+e);
}
}
}
3、随机流
(1)类RandomAccessFile允许对文件内容同时完成读和写操作，它直接继承object，并且同时实现了接口DataInput和DataOutput，提供了支持随机文件操作的方法：
(2)不区分输入流输出流，对文件访问一定要指定访问方式，(rw)可以随机访问文件某一位置的字符,可以以二进制的方式对数据进行存储,可以随机调整文件位置指针，随机输出。
(3)经典面试例子
例
import java.io.*;
public class random_file
{
public static void main(String args[])
{
int[] data_arr = {12,31,56,23,27,1,43,65,4,99};
try
{
RandomAccessFile randf = new RandomAccessFile("temp.dat","rw");
for (int i = 0; i < data_arr.length; i++)
randf.writeInt(data_arr[i]);
for(int i=data_arr.length-1; i>=0; i--)
{
randf.seek(i*4);
System.out.println(randf.readInt());//倒叙输出
}
randf.seek(8);//跳8个字节输出结果
System.out.println(randf.readInt());//56
System.out.println(randf.readInt());//23
randf.skipBytes(8);
System.out.println(randf.readInt());//43
randf.close();
}catch (IOException e){
System.out.println("File access error: "+e);
}
}
}
4、过滤流
(1)BufferStream
BufferInputStream和BufferOutputStream必须套接在字节流上，顺序读取；
Buffer流是过滤流，不能单独使用，并且区分输入流和输出流；
只能处理文本文件，不能一次读一行，一次能读取若干字节的字符，没有做本质的改变；
例
import java.io.*;
public class BufferedStreamDemo{
public static void main(String[] args){
try{
FileInputStream in = new FileInputStream(".//data1.txt");
BufferedInputStream fin = new BufferedInputStream(in);
FileOutputStream out = new FileOutputStream(".//data2.txt");
BufferedOutputStream fout = new BufferedOutputStream(out);
byte[] buf = new byte[512];
int c = 0;
while((c = fin.read(buf, 0, 512)) != -1){
System.out.println("c = " + c);
fout.write(buf, 0, c);
}
fin.close();
fout.close();
}catch(FileNotFoundException e){
System.out.println("File Not Found!");
}catch(IOException e){
System.out.println("I/O Error!");
}
}
}
(2)DataStream
Data流也是套接流，一定要套接在字节流上，区分输入输出
DataInputStream
DataOutputStream
既可以套接文件字节流，也可以套接在网络上（很多）
（1）套接在文件流上
（2）可以一次读取一行的字符
（3）可以对汉字做编码
（4）不仅处理文本文件，也可以处理二进制文件
例
import java.io.*;
public class datainput_output
{
public static void main(String args[])throws IOException
{
FileOutputStream fos = new FileOutputStream("a.txt");
DataOutputStream dos = new DataOutputStream (fos);
try
{
dos.writeBoolean(true);
dos.writeByte((byte)123);
dos.writeChar('J');
dos.writeDouble(3.141592654);
dos.writeFloat(2.7182f);
dos.writeInt(1234567890);
dos.writeLong(998877665544332211L);
dos.writeShort((short)11223);
}
finally
{
dos.close();
}
FileInputStream fis = new FileInputStream("a.txt");
DataInputStream dis = new DataInputStream(fis);
try
{
System.out.println("\t "+dis.readBoolean());
System.out.println("\t "+dis.readByte());
System.out.println("\t "+dis.readChar());
System.out.println("\t "+dis.readDouble());
System.out.println("\t "+dis.readFloat());
System.out.println("\t "+dis.readInt());
System.out.println("\t "+dis.readLong());
System.out.println("\t "+dis.readShort());
}
finally
{
dis.close();
}
}
}
(3)ObjectStream
也是过滤流，只处理二进制文件，不能处理文本文件
序列化：（串行化）：把自己的状态（属性值）放在对象输出流中传送就叫。。
1，这个类一定要加入串行化协议String类和封装类就加入了串行化协议。
2，创建出类的对象，new Student()，为类的实例全局变量赋值。
3，创建对象输出流，先创建字节流，再套接在对象流上。
4，对象输出流对象的writeObject()方法，写进流中。
例
public class Student implements Serializable//串行化协议
{
int id;
String name;
int age;
String department;
public Student(int id, String name, int age, String department)
{
this.id = id;
this.name = name;
this.age = age;
this.department = departmernt;
}
}
反序列化：
通过文件对象输入流读取对象的状态，再生出对象。
1，创建对象输入流对象，先创建文件输入流对象。
2，从对象所指文件读取对象的状态，readObject()再生成对象object造型为student。
3，串行化加反串行化叫做对象的持续性。
对象的串行化只保存对象的属性（状态）。
瞬时的状态也不可保存，用transient标注，这时对象属性不能传送。
例
public class Objectser
{
public static void main(String args[])
{
Student stu = new Student(981036,“Li Ming”, 16,“CSD”);
try
{
FileOutputStream fo = new FileOutputStream(“data.ser”);
ObjectOutputStream so = new ObjectOutputStream(fo);
so.writeObject(stu);
so.close();
}
catch(Exception e)
{
System.out.println(e) ;
}
}
}
5、管道流PipedStream
分管道输入流和输出流 ，在线程中传数据，生产者消费者模式与这个相结合。
例
import java.io.*;
/**
*管道流和生产者消费者相结合
*@TestPipePC测试管道流和线程结合类
*@Wang Cy 2016/0803
*/
public class TestPipePC
{
public static void main(String[] args)
{
//创建管道输出流
PipedInputStream pis = new PipedInputStream();
//创建管道输出流
try{
PipedOutputStream pos = new PipedOutputStream(pis);
//生产者线程
Producer p = new Producer(pos);
//创建消费者线程
Consumer c = new Consumer(pis);
//激活线程
p.start();
c.start();
}catch(IOException e){
System.out.println(e);
}
//管道流是不是无法实现三个或以上的线程通信
}
}
//生产者线程
class Producer extends Thread
{
private PipedOutputStream pos;
public Producer(PipedOutputStream pos)
{
this.pos = pos;
}
public void run()
{
int i = 0;
try {
while(i<10)
{
this.sleep(1000);
pos.write(i);
System.out.println("生产者："+i);
i++;
}
} catch (IOException e) {
e.printStackTrace();
} catch(InterruptedException e2){
e2.printStackTrace();
}
}
}
//消费者线程
class Consumer extends Thread
{
private PipedInputStream pis;
public Consumer(PipedInputStream pis)
{
this.pis = pis;
}
public void run()
{
try
{
while(true)
{
System.out.println("消费者:"+pis.read());
}
} catch (IOException e1) {
}
}
}
6、顺序输入流SequenceStream
只对文件字节输入流做链接
import java.io.*;
public class SequenceStream
{
public static void main(String args[])
{
try
{
FileInputStream f1,f2;
String s;
f1 = new FileInputStream("file1.txt");
f2 = new FileInputStream("data1.txt");
SequenceInputStream fs = new SequenceInputStream(f1, f2);//对两个输入流做连接
DataInputStream ds = new DataInputStream(fs);
while( (s = ds.readLine()) != null )
System.out.println(s);
f1.close();
f2.close();
}catch(FileNotFoundException e) {
System.out.println("FileStreamsTest: "+e);
}catch(IOException e) {
System.err.println("FileStreamsTest: "+e);
}
}
}
7、PrintStream标准流
被system继承，加载主方法时，通过system创建3个对象，in,out,err
8、字符流
字符流不能读取二进制文件，只能处理文本文件。
import java.io.*;
public class FileTOUnicode
{
public static void main(String args[])
{
try
{
FileInputStream fis = new FileInputStream("file1.txt");
InputStreamReader dis = new InputStreamReader(fis);
// InputStreamReader dis = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(dis);
String s;
while( (s = reader.readLine()) != null )
{
System.out.println("read: "+s);
}
dis.close();
}catch(IOException e)
{
System.out.println(e);
}
}
}
�"�����u�vB��