流

在java程序中，对于数据的输入/输出操作以“流”（stream）方式进行，jdk提供了各式各样的“流”类，用来获取不同种类的数据；程序中通过标准的方法输入或输出数据
java.io包定义了多个流类型（类或抽象类）来实现输入/输出功能；可以从不同的角度对其进行分类:

1.按数据流的方向可以分为输入流和输出流；
2.按照处理数据单位不同可以分为字节流和字符流;
3.按照功能不同可以分为节点流和处理流;

jdk所提供的所有流类型位于包java.io内都分别继承自以下四种流类型：

输入/输出	字节流	字符流
输入流	InputStream	Reader
输出流	OutpuStream	Writer

节点流和处理流：
1.节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）：


2.处理流是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理 为程序提供更为强大的读写功能。





InputStream:
继承自InputStream的流都是用于向程序中输入数据，且数据的单位为字节（8 bit=1byte)
InputStream的子类:
AudioInputStream,FileInputStream,InputStream, ObjectInputStream,PipedInputStream,SequenceInputStream,
StringBufferInputStream,FilterInputStream的子类(BufferedInputStream, CheckedInputStream, CipherInputStream, DataInputStream, DeflaterInputStream, DigestInputStream, InflaterInputStream, LineNumberInputStream, ProgressMonitorInputStream, PushbackInputStream)
InputStream的基本方法可以参考API，这里不具体介绍了.

OutputStream:
继承自OutputStream的流用于输出数据，且数据单位为字节（8bit）
OutputStream的子类:
ByteArrayOutputStream, FileOutputStream,  ObjectOutputStream, OutputStream, PipedOutputStream,FilterOutputStream的子类（BufferedOutputStream, CheckedOutputStream, CipherOutputStream, DataOutputStream, DeflaterOutputStream, DigestOutputStream, InflaterOutputStream, PrintStream）
OutputStream的基本用法可以参考API.


Reader:
继承自Reader的流都是用于向程序中输入数据，且数据的单位是字符（16bit=2byte）
Reader子类：
BufferedReader的子类（LineNumberReader）, CharArrayReader, FilterReader的子类（PushbackReader）, InputStreamReader的子类（FileReader）, PipedReader, StringReader
Reader基本用法参考API,同上。



Writer:
继承自Writer的流都是用于程序中输入数据，且数据的单位为字符（16bit,2byte)1byte = 8bits(8位）
Writer的子类：
BufferedWriter, CharArrayWriter, FilterWriter, OutputStreamWriter的子类（FileWriter）, PipedWriter, PrintWriter, StringWriter
Writer的基本用法参考API,同上。

下面再通过图解直观 InputStream/OutputStream 与 Reader/Writer：

1.继承自InputStream/OutputStream的流是用于向程序中输入/输出数据，深色的为节点流，浅色的为处理流。

2.继承自Reader/Writer的流是用于向程序中输入/输出数据，如图，深色的为节点流，浅色的为处理流。

下面简单的介绍下常用的流类型：

缓冲流：
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率。
jdk提供了四种缓冲流：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存中的数据立刻写出

点击(此处)折叠或打开

 public class TestFileInputStream {

     public static void main(String[] args){

         FileOutputStream out = null;
         FileInputStream in = null;


             try{
             out = new FileOutputStream("B:/Java/src/IO/diy.txt");
             in = new FileInputStream("B:/Java/src/IO/diy.txt");
             out.write(11);
             out.close();
             }catch(IOException e1){

             System.out.println("找不到文件");
             e1.printStackTrace();
             System.exit(-1);
         }

         int ss = 0;

         try{
         while((ss = in.read()) != -1){

             System.out.println(ss);
       }
     }catch(IOException e2){

         e2.printStackTrace();
     }
   }
 }

点击(此处)折叠或打开

 public class TestFileReader {

     public static void main(String[] args){

     FileReader re = null;
     FileWriter wr = null;

     try{
          wr = new FileWriter("B:/Java/src/diy.txt");
          for(int i =0;i<65535;i++){
             wr.write(i);
          }
         wr.close();
      }catch(IOException e1){

         e1.printStackTrace();
         System.exit(-1);
      }

     try{

         re = new FileReader("B:/Java/src/diy.txt");

     }catch(FileNotFoundException e){

         System.out.println("文件不存在");
         e.printStackTrace();
         System.exit(-1);
     }

     try{
         int i = 0;
         while((i = re.read()) != -1){

             System.out.print((char)i);
         }
          re.close();
         }catch(IOException e){

            e.printStackTrace();
     }
   }
 }

转换流：
InputStreamReader和OutputStreamWriter用于字节数据到字符数据之间的转换
InputStreamReader 需要和InputStream "套接"
OutputStreamWriter需要和OutputStream"套接"

点击(此处)折叠或打开

 public class TransStreamWR {

     public static void main(String[] args){
     OutputStreamWriter out = null;
     InputStreamReader red = null;

     try{
         out = new OutputStreamWriter(new FileOutputStream("B:/Java/src/diy.txt"));
         red =new InputStreamReader(new FileInputStream("B:/Java/src/diy.txt"));

           for(int i = 0;i<65535;i++){

              out.write(i);
         }

         out.flush();
         out.close();
     }catch(IOException e){

         e.printStackTrace();
         System.exit(-1);
      }

     try{

         int ss = 0;
         while((ss = red.read()) != -1){

            System.out.println(ss);
         }

         red.close();
     }catch(IOException e){

         e.printStackTrace();
         System.exit(-1);

     }
   }
 }

有朋友会问，为什么没有把字符流转换为字节流呢，完全没有这个必要！既然可以一下读取两个字节，为什么要换成读取一个字节的呢，如果需要读取一个字节，那直接用字节流处理就行了。

数据流：
DataInputStream和DataOutputStream分别继承自InputStream和OutputStream,它属于处理流，需要分别 ”套接“在InputStream和OutputStream类型的节点流上
DataInputStream和DataOutputStream提供了可以存取与机器无关的java原始类型数据（如：int，double等）

点击(此处)折叠或打开

 public class TestDataStream {

     public static void main(String[] args){

         DataOutputStream doo = null;
         DataInputStream di = null;
         ByteArrayOutputStream bar = new ByteArrayOutputStream();
         ByteArrayInputStream bit = null;
      try{

          doo = new DataOutputStream(bar);
          doo.writeInt(1);
          doo.writeChar('w');
          doo.writeFloat((float) 33.3);
          doo.writeDouble(1111111111.1111111111111111);
          doo.writeBoolean(false);
          bit = new ByteArrayInputStream(bar.toByteArray());
          doo.flush();
          doo.close();
          bar.close();
      }catch(IOException e){

          e.printStackTrace();
          System.exit(-1);
      }

      try{

          di = new DataInputStream(bit);
          System.out.println(di.readInt());
          System.out.println(di.readChar());
          System.out.println(di.readFloat());
          System.out.println(di.readDouble());
          System.out.println(di.readBoolean()); //一定要按照顺序读取，否则会出现错误答案
      }catch(IOException e){

          e.printStackTrace();
          System.exit(-1);
     }
    }
  }

===============================================================================================
Print流：

PrintWriter和PrintStream都属于输出流，分别针对与字符和字节
PrintWriter和PrintStream提供了重载的print
println方法用于多种数据类型的输出
PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检查错误状态获取错误信息
PrintWriter和PrintStream有自动flush功能

点击(此处)折叠或打开

 public class TestPrintStream {

     public static void main(String[] args){

         PrintStream pr = null;

         try{

             pr = new PrintStream(new FileOutputStream("B:/Java/src/diy.log"));

         }catch(IOException e){

             e.printStackTrace();
         }

         if(pr != null)
         System.setOut(pr);

         for(int i = 0;i<60000;i++){

             System.out.print((char)i);
         }
     }
 }

Object流：
直接将Object写入或读出
这其中涉及三个重要的关键字：
transient
serializable
externalizable

点击(此处)折叠或打开

 public class S implements Serializable{ //可以被序列化

     int i = 32;
     int j = 9;
     transient int m = 11; //隐藏不可见

 }

如果该类被存放在Object流中，则该类必须实现serializable接口，就是可以被序列化。查看API可以发现，该接口无任何方法和成员变量。
如果成员变量被transient修饰，则在被序列化时，该变量不被存放在流中，流对其不可见。

点击(此处)折叠或打开

 public class TestObject{

      public static void main(String[] args) throws Exception{

          FileInputStream in = null;
          S s = new S();
          s.m = 8;

          FileOutputStream fos = new FileOutputStream("B:/Java/src/diy.txt");
             ObjectOutputStream so = new ObjectOutputStream(fos);
              so.writeObject(s);
              so.flush();
              so.close();
             FileInputStream fis = new FileInputStream("B:/Java/src/diy.txt");
             ObjectInputStream ois = new ObjectInputStream(fis);
             try{
             S t = (S)ois.readObject();
             System.out.println(t.i + " " + " " + t.j + " " + t.m);
             }catch(ClassNotFoundException e1){

                 e1.printStackTrace();
             }catch (IOException e2) {

                 e2.printStackTrace();
        }
      }
   }

当一个类要使用externalizable这个接口的时候，自定义序列化，可以发现 externalizable实现了 Serializable 接口，而且有两个成员函数：

void	readExternal(ObjectInput in) The object implements the readExternal method to restore its contents by calling the methods of DataInput for primitive types and readObject for objects, strings and arrays.
void	writeExternal(ObjectOutput out) The object implements the writeExternal method to save its contents by calling the methods of DataOutput for its primitive values or calling the writeObject method of ObjectOutput for objects, strings, and arrays.

上面简单的介绍了java中的流，用于学习总结，如有不当之处，请读者指正！