字节流         字符流
输入流      InputStream      Reader
输出流      OutputStream     Writer

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

上来就是这样的管道。现在来细细理解一下，如果一根管道怼到一个文件上读数据，站在文件的角度上这叫输出，站在程序的角度上这就叫输入。以后说输入流输出流都是站在程序的角度上。节点流就是流直接怼在数据源上，套在其他管道之上的流叫处理流。

//将输出流中缓冲的数据全部写到目的地，这个就避免还有一半没写完的时候流被close掉
void flush() throws IOException

这里值得注意的是一个中文是两个字节所以如果用字节流读中文肯定是乱码。下面看一个用得较多的BufferReader和BufferWriter的例子小程序，深入理解一下管道套管道的机制并熟悉常见的用法。

import java.io.*;
public class TestBufferStream2 {
  public static void main(String[] args) {
    try {
      BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\share\\java\\dat2.txt"));
      BufferedReader br = new BufferedReader(
             new FileReader("d:\\share\\java\\dat2.txt"));
      String s = null;
      for(int i=1;i<=100;i++){
        s = String.valueOf(Math.random());
        bw.write(s);
        bw.newLine();
      }
      bw.flush();
      while((s=br.readLine())!=null){
        System.out.println(s);
      }
      bw.close(); 
      br.close();
    } catch (IOException e) { e.printStackTrace();}
  }
}

字节流转换字符流

import java.io.*;
public class TestTransForm1 {
  public static void main(String[] args) {
    try {
      OutputStreamWriter osw = new OutputStreamWriter( new FileOutputStream("d:\\bak\\char.txt"));
      osw.write("mircosoftibmsunapplehp");
      System.out.println(osw.getEncoding());
      osw.close();
      osw = new OutputStreamWriter( new FileOutputStream("d:\\bak\\char.txt", true),
      "ISO8859_1"); // latin-1
      //解释一下true，这个参数就是接着后面写不把前面的覆盖掉
      osw.write("mircosoftibmsunapplehp");
      System.out.println(osw.getEncoding());
      osw.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

下面也是一个转换的例子，是读键盘输入，比Scaner好用一点。

import java.io.*;
public class TestTransForm2 {
  public static void main(String args[]) {
    InputStreamReader isr = 
            new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);
    String s = null;
    try {
      s = br.readLine();
      while(s!=null){
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        s = br.readLine();
      }
      br.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
} //阻塞

DataInputStream和DataOutputStream是处理流需要套在InputStream和OutputStream上使用，它提供了可以存取与机器无关的Java原始类型数据。

import java.io.*;
public class TestDataStream {
  public static void main(String[] args) {
    ByteArrayOutputStream baos = 
                        new ByteArrayOutputStream(); 
    DataOutputStream dos = 
                        new DataOutputStream(baos);
    try {
      dos.writeDouble(Math.random());
      dos.writeBoolean(true);
      ByteArrayInputStream bais = 
          new ByteArrayInputStream(baos.toByteArray());
      System.out.println(bais.available());
      DataInputStream dis = new DataInputStream(bais);
      System.out.println(dis.readDouble());
      System.out.println(dis.readBoolean());
      dos.close();  dis.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

仔细看图就能明白DataInputStream和DataOutputStream的用法和注意点，而且在内存中是怎么分布的也可以弄清楚。

Print流

import java.io.*;
public class TestPrintStream1 { 
  public static void main(String[] args) {
    PrintStream ps = null;
    try {
      FileOutputStream fos = 
              new FileOutputStream("d:\\bak\\log.dat");
      ps = new PrintStream(fos);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if(ps != null){
      System.setOut(ps);
    }
    int ln = 0;
    for(char c = 0; c <= 60000; c++){
      System.out.print(c+ " ");
      if(ln++ >=100){ System.out.println(); ln = 0;}
    }
  }
}

这里值得注意的是setOut之后System.out.print不在输出到屏幕而是指向ps，输入进了文件。

Object流

import java.io.*;

public class TestObjectIO {
    public static void main(String args[]) throws Exception {
        T t = new T();
        t.k = 8;
        FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(t);
        oos.flush();
        oos.close();

        FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        T tReaded = (T)ois.readObject();
        System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);

    }
}

class T implements Serializable {
    //空接口，标记性借口，没有实现的方法
    int i = 10;
    int j = 9;
    double d = 2.3;
    int k = 15;
    //transient int k = 15;
    //这里解释一下transient，透明的，如果标记这个之后这个值在序列化的时候是不予考虑的，默认为0
}

序列化去实现Serializable 接口，如果想控制我们的对象怎么去写过去的就去实现externalizable接口，它是Serializable的子接口，去实现它两个方法，自己可以控制自己的序列化过程。