java I/O 流总结学习

java io 总结

1. 总起
了解java io，只要搞清楚5个类，指的是File、OutputStream、InputStream、Writer、Reader；

2. File
file就是最基本的文件操作对接。我们只需了解其用法即可。

3. InputStream
字节输入流，

FileInputStream:从文件系统的某个文件中获取输入字节。（文件–>字节流）
一般用法：

FileInputStream fis=new FileInputStream(new File("D:\\123.txt"));//新建一个FileInputStream对象
try {
   //int read();读取一个byte类型的数据，返回值是高位补0的int类型。若返回-1说明没有读取到任何字节读取工作介绍
   //第一种，一个个字节读取
   while (fis.read() !=-1){
       //do something

   }
   //int available() ：返回输入流中可以读取的字节数。注：若输入阻塞，当前线程被挂起，如果调用这个方法的话，返回0，
   // 这个方法只有子类对象调用才有用。
   //int read(byte[] b);读取b.length个字节的数据放到b数组中。返回值是读取的字节数。
   //int read(byte[] b,int off,int len);从输入流中最多读取len个字节存放到偏移量为off的数组中
   //第二种，全部读取放入数组
   byte[] b=new byte[fis.available()];//新建一个字节数组
   fis.read(b);//将文件中的内容读取到字节数组中,返回值为读取的字节数
   fis.close();

   String str2=new String(b);//再将字节数组中的内容转化成字符串形式输出
   System.out.println(str2);

   //使用FileOutputStream输出
   FileOutputStream fos = new FileOutputStream(new File("D:\\123_copy.txt"));
   fos.write(b);//write方法对应read3个方法
   fos.close();
   //关于flush方法，是用在当流有缓冲区的时候，迫使所有缓冲的输出数据被写出到底层输出流中。
   //FileOutputStream的没有做缓存处理，这里的flush无意义。
} catch (IOException e) {
   e.printStackTrace();
}

上面的例子可以适用于所有的输入流，输出流，只是流的构造方法不一致了，读取和写入完全一致。
ByteArrayInputStream: 把字节数据变为输入流。（字节数组–>字节流）

    new ByteArrayInputStream(byte buf[])

ObjectInputStream: 把对象作为流。注：所读写的对象必须实现Serializable接口，对象中的transient和static类型成员变量不会被读取和写入。（字节流–>对象）

ObjectInputStream in=new ObjectInputStream(InputStream in);//可以从各种流中获取
(Student)in.readObject();从流中读出student对象。
in.close;

ObjectOutputStream out=new ObjectOutputStream(OutputStream fout);
out.writeObject(s1);//往流里写入对象
out.close();

以上三个前两个是从不同的介质中读取信息到流中（或者可理解成转化），后一个是从流中读取对象。这三个基本上满足了流的输入需求。

SequenceInputStream:用于合并流，流A+流B成为新的字节流。

public SequenceInputStream(Enumeration<? extends InputStream> e)
SequenceInputStream(InputStream s1, InputStream s2)

PipedInputStream:管道流，这个比较特殊，用于在各个线程间流数据的传递。线程A往流写东西，线程B读取。详细请看代码示例：

/*  
管道流:
PipedInputStream
void connect(PipedOutputStream src) 
使此管道输入流连接到管道输出流 src
PipedOutputStream
void connect(PipedInputStream snk)  
在JDK我们看到PipedInputStream中有管道缓冲区,用来接收数据
管道流内部在实现时还有大量的对同步数据的处理
管道输出流和管道输入流执行时不能互相阻塞,所以一般要开启独立线程分别执行
顺便复习了多线程操作
[示例]:管道流
*/
import java.io.*;
class Demo            
{
  public static void main(String[] args)  throws Exception
  {
    PipedInputStream pin = new PipedInputStream();
    PipedOutputStream pout = new PipedOutputStream();
    pin.connect(pout);  //输入流与输出流连接
    ReadThread readTh   = new ReadThread(pin);
    WriteThread writeTh = new WriteThread(pout);
    new Thread(readTh).start();
    new Thread(writeTh).start();
  }
  public static void sop(Object obj) //打印
  {
    System.out.println(obj);
  }
}
class ReadThread implements Runnable
{
  private PipedInputStream pin;
  ReadThread(PipedInputStream pin)   //
  {
    this.pin=pin;
  }
  public void run() //由于必须要覆盖run方法,所以这里不能抛,只能try
  {
    try
    {
      sop("R:读取前没有数据,阻塞中...等待数据传过来再输出到控制台...");
      byte[] buf = new byte[1024];
      int len = pin.read(buf);  //read阻塞
      sop("R:读取数据成功,阻塞解除...");

      String s= new String(buf,0,len);
      sop(s);    //将读取的数据流用字符串以字符串打印出来
      pin.close();     
    }
    catch(Exception e)
    {
      throw new RuntimeException("R:管道读取流失败!");
    }   
  }
  public static void sop(Object obj) //打印
  {
    System.out.println(obj);
  }
}
class WriteThread implements Runnable
{
  private PipedOutputStream pout;
  WriteThread(PipedOutputStream pout)
  {
    this.pout=  pout;
  }
  public void run()
  {
    try
    {
      sop("W:开始将数据写入:但等个5秒让我们观察...");
      Thread.sleep(5000);  //释放cpu执行权5秒
      pout.write("W: writePiped 数据...".getBytes());  //管道输出流
      pout.close();
    }
    catch(Exception e)
    {
      throw new RuntimeException("W:WriteThread写入失败...");
    }
  }
  public static void sop(Object obj) //打印
  {
    System.out.println(obj);
  }
}

以上两个流可以理解为是特殊工具类。
FilterInputStream:该流是一个空壳，用来实现装饰模式的父类。该类的子类都是包装现有流，使现有的流增加新的特性。
BufferedInputStream:给流增加缓存的特性，把流内容缓存在内部一个字节数组中，之后如再取，就直接从数组中获取，从而提高读取效率。

    public BufferedInputStream(InputStream in)

PushbackInputStream:给流增加能回读的特性，一般用于一个文件多种编码，要不停的调整读取的位置。
DateInputStream:赋予了流以不同的方式读取流的功能。比如用utf-8读取。
以上三个为增加流特性的工具类，用于拓展流的功能。
LineNumberInputStream:已过时，弃用
StringBufferInputStream:已过时，弃用

4. OutputStream

基本上和inputStream一一对应，毕竟是好基友嘛！
但是里面有个PrintStream,用于控制台输出的。我们常用的System.out就是这个。（唯一单身）

5. Reader

使用方法和inputStream基本一致。
InputStreamReader:把字节流转为字符流。一般拿来读取文件。就比如下面的子类FileReader.
FilterReader,PushbackReader,BufferedReader,PipedReader都和对应的相关inputStream功能类似。可以参照InputStream的用法。
CharArrayReader：对应于ByteArrayInputStream由于这边是字符流，所以是从字符数组读取的。（字符数字–>字符流）
LineNumberReader:装饰类，给流加上行号。（在inputStream是被废弃的）

6. Write

全部和reader一一对应，别问我为什么。

7. 后记
看了前面的详细说明，是不是再也不怕操控流了呢？是不是很简单？