程序員自學之旅（三）IO流

輸入輸出流、常見的節點流和處理流、文件流、緩衝流、數據流、轉換流、Print流、Object流
輸入輸出是站在程序的角度說的
               字節流               字符流
輸入流  InputStreeam    Reader
輸出流  OutputStrean     Writer


節點流類型
類型                          字符流                            字節流
File（文件）          FileReader                     FileInputStream
                                 FileWriter                        FileOutputStream
Memory Array        CharArrayReader          ByteArrayInputStream
                                CharArrayWriter              ByteArrayOutputStream
Memory String      StringReader
                                 StringWriter
Pipe                        PipedReader                  PipedInoutStream
                                PipedWriter                      PipedOutputStream

FileInputStream的事例：
import java.io.*;
public class TestFileInputStream {
  public static void main(String[] args) {
    int b = 0;
    FileInputStream in = null;
    try {
      in = new FileInputStream("d:\\share\\java\\io\\TestFileInputStream.java");
    } catch (FileNotFoundException e) {
      System.out.println("找不到指定文件");
      System.exit(-1);
    }
    
    try {
      long num = 0;
      while((b=in.read())!=-1){
        System.out.print((char)b);
        num++;
      }
      in.close();  
      System.out.println();
      System.out.println("共讀取了 "+num+" 個字節");
    } catch (IOException e1) {
      System.out.println("文件讀取錯誤"); System.exit(-1);
    }
  }
}
FileOutputStream事例：
import java.io.*;
public class TestFileOutputStream {
  public static void main(String[] args) {
      int b = 0;
      FileInputStream in = null;
      FileOutputStream out = null;
      try {
        in = new FileInputStream("d:/share/java/HelloWorld.java");
        out = new FileOutputStream("d:/share/java/io/HW.java");
        while((b=in.read())!=-1){
          out.write(b);
        }
        in.close();
        out.close();
      } catch (FileNotFoundException e2) {
        System.out.println("找不到指定文件"); System.exit(-1);
      } catch (IOException e1) {
        System.out.println("文件複製錯誤"); System.exit(-1);
      }
      System.out.println("文件已複製");
  }
}
FileReader事例：
import java.io.*;
public class TestFileReader {
  public static void main(String[] args) {
    FileReader fr = null;
    int c = 0;
    try {
      fr = new FileReader("d:\\share\\java\\io\\TestFileReader.java");
      int ln = 0;
      while ((c = fr.read()) != -1) {
        //char ch = (char) fr.read();
        System.out.print((char)c);
        //if (++ln >= 100) { System.out.println(); ln = 0;}
      }
      fr.close();
    } catch (FileNotFoundException e) {
      System.out.println("找不到指定文件");
    } catch (IOException e) {
      System.out.println("文件讀取錯誤");
    }

  }
}
FileWriter事例：
import java.io.*;
public class TestFileWriter {
  public static void main(String[] args) {
    FileWriter fw = null;
    try {
      fw = new FileWriter("d:\\bak\\unicode.dat");
      for(int c=0;c<=50000;c++){
        fw.write(c);
      }
      fw.close();
    } catch (IOException e1) {
        e1.printStackTrace();
      System.out.println("文件寫入錯誤");
      System.exit(-1);
    }
  }
}
處理流類型
處理類型                        字符流                              字節流
Buffering                       BufferedReader            BufferedInputStream
                                        BufferedWriter               BufferedOutputStream
Filtering                         FilterReader                  FilterInputStream
                                       FilterWriter                     FilterOutputStream
converting between    InputStreamReader
bytes and character    OutputStreamWriter

Object                                                                     ObjectInputStream
Serialization                                                           ObjectOutputStream

Data conversion                                                     DataInputStream
                                                                                   DataOutputStream
Counting                       LineNumberReader    LineNumberInputStream
Peeking                          PusbackReader           PushbackInputStream
Ptinting                           PrintWrite                          PrintStream

緩衝流
BufereSream事例1：
import java.io.*;
public class TestBufferStream1 {
  public static void main(String[] args) {
    try {
      FileInputStream fis =
              new FileInputStream("d:\\share\\java\\HelloWorld.java");
      BufferedInputStream bis =
              new BufferedInputStream(fis);
      int c = 0;
      System.out.println(bis.read());
      System.out.println(bis.read());
      bis.mark(100);//標記100這個點可以蟲這個點開始讀取
      for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
        System.out.print((char)c+" ");
      }
      System.out.println();
      bis.reset();
      for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
        System.out.print((char)c+" ");
      }
      bis.close();
    } catch (IOException e) {e.printStackTrace();}
  }
}
BufferStream事例2：
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();}
  }
}

轉換流
字節轉換成字符：
事例1：
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
      osw.write("mircosoftibmsunapplehp");
      System.out.println(osw.getEncoding());
      osw.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}
事例2：
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();
    }
  }
} //阻塞

數據流：
把數據轉換成想用的數據
事例：
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());//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();
    }
  }
}
print流
不會拋異常
事例1：
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;}
    }
  }
}
事例2：
import java.io.*;
public class TestPrintStream2 {
  public static void main(String[] args) {
    String filename = args[0];
    if(filename!=null){list(filename,System.out);}
  }
  public static void list(String f,PrintStream fs){
    try {
      BufferedReader br =
                  new BufferedReader(new FileReader(f));
      String s = null;
      while((s=br.readLine())!=null){
        fs.println(s);            
      }
      br.close();
    } catch (IOException e) {
      fs.println("無法讀取文件");
    }
  }
}
事例3：
import java.util.*;
import java.io.*;
public class TestPrintStream3 {
  public static void main(String[] args) {
    String s = null;
    BufferedReader br = new BufferedReader(
                        new InputStreamReader(System.in));
    try {
      FileWriter fw = new FileWriter
                           ("d:\\bak\\logfile.log", true); //Log4J
      PrintWriter log = new PrintWriter(fw);
      while ((s = br.readLine())!=null) {
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        log.println("-----");
        log.println(s.toUpperCase());
        log.flush();
      }
      log.println("==="+new Date()+"===");
      log.flush();
      log.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}
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//Serializable標記接口，想序列某個對象必須實現Serializable接口
{
    int i = 10;
    int j = 9;
    double d = 2.3;
    transient int k = 15;
}