java IO流

流的分類

• 按數據流的方向不同可以分爲輸入流和輸出流
• 按處理數據單位不同可以分爲字節流和字符流
• 按照功能不同可以分爲節點流和處理流

節點流和處理流

FileInputStream & FileOutputStream

//字節流
public class TestFileInputStream {
    public static void main(String[] args) {
        int b = 0;
        FileInputStream in = null;
        try {
            in = new FileInputStream("F:/DB/abc.txt");
        } catch (FileNotFoundException e) {
            System.out.println("系統找不到指定文件!");
            System.exit(-1);
        }

        try {
            long num = 0;
            while((b = in.read()) != -1) {
                System.out.println((char)b);
                num++;
            }
            in.close();
            System.out.println();
            System.out.println("共讀取了" + num + "個字節");
        } catch (IOException e) {
            System.out.println("文件讀取錯誤");
            System.exit(-1);
        }
    }
}

//字節流[文件複製]
public class TestFileOutputStream {
    public static void main(String[] args) {
        int b = 0;
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream("F:/DB/abc.txt");
            out = new FileOutputStream("F:/DB/def.txt");
            while((b = in.read()) != -1) {
                out.write(b);
            }
            in.close();
            out.close();
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件");
            System.exit(-1);
        } catch (IOException e) {
            System.out.println("文件複製錯誤");
            System.exit(-1);
        }
        System.out.println("文件已複製");
    }
}

FileReader & FileWriter

//字符流
public class TestFileReader {
    public static void main(String[] args) {
        int c = 0;
        FileReader in = null;
        try {
            in = new FileReader("F:/DB/abc.txt");
        } catch (FileNotFoundException e) {
            System.out.println("系統找不到指定文件!");
            System.exit(-1);
        }

        try {
            long num = 0;
            while((c = in.read()) != -1) {
                System.out.println((char)c);
                num++;
            }
            in.close();
            System.out.println();
            System.out.println("共讀取了" + num + "個字節");
        } catch (IOException e) {
            System.out.println("文件讀取錯誤");
            System.exit(-1);
        }
    }
}

//字符流
public class TestFileWriter {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("F:/DB/abc.dat");
            for(int c = 0; c <=50; c++) {
                fw.write(c);
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件寫入錯誤");
            System.exit(-1);
        }

    }
}

BufferedInputStream & BufferedOutputStream

//字節緩衝流
public class TestBufferStream1 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("F:/DB/abc.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            int c = 0;
            System.out.println((char)bis.read());
            System.out.println((char)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();
        }
    }
}

BufferedReader & BufferedWriter

//字符緩衝流
public class TestBufferStream2 {
    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new FileReader("F:/DB/random.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("F:/DB/random.txt"));
            String s = null;
            for(int i = 0; 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();
        }
    }
}

DataInputStream & DataOutputStream & ByteArrayInputStream & ByteArrayOutputStream

//對基本的數據類型進行讀寫
public class TestDataStream {
    public static void main(String[] args) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            DataOutputStream dos = new DataOutputStream(baos);
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            DataInputStream dis = new DataInputStream(bais);
            System.out.println(dis.available());
            System.out.println(dis.readDouble());   //先寫到字節數組中的數據先讀
            System.out.println(dis.readBoolean());
            dos.close();    dis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

InputStreamReader & OutputStreamWriter

//轉換流[將字節流轉換成字符流]
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();
        }
    }
}

//轉換流[將字節流轉換成字符流]
public class TestTransform1 {
    public static void main(String[] args) {
        try {
            //OutputStreamWriter將字節流轉換成字符流輸出
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:/DB/transform.txt"));
            osw.write("amazine1");
            System.out.println(osw.getEncoding());
            osw.close();
            //FileOutputStream第二個參數爲true表示追加
            osw = new OutputStreamWriter(new FileOutputStream("F:/DB/transform.txt",true),"ISO8859_1");
            osw.write("amazine2");
            System.out.println(osw.getEncoding());
            osw.close();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PrintStream & PrintWriter

//打印流
public class TestPrintStream1 {
    public static void main(String[] args) {
        try {
            PrintStream ps = null;
            FileOutputStream fos = new FileOutputStream("F:/DB/log.dat");
            ps = new PrintStream(fos);
            int in = 0;
            //打印到Console窗口
            for(char c = 0; c < 60000; c++) {
                System.out.print(c + " ");
                if(in++ >= 100) {//每行打印100個數
                    System.out.println();
                    in = 0;
                }
            }
            if(ps != null) {//輸出重定向
                System.setOut(ps);
            }
            //打印到文件中去
            for(char c = 0; c < 60000; c++) {
                System.out.print(c + " ");
                if(in++ >= 100) {//每行打印100個數
                    System.out.println();
                    in = 0;
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

//打印流
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 fileName, PrintStream fs) {
        try {
            BufferedReader br = new BufferedReader(new FileReader(fileName));
            String s = null;
            while((s = br.readLine()) != null) {
                fs.println(s);
            }
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            fs.println("無法讀取文件！");
        }
    }
}

//模擬日誌
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("F:/DB/logtxt.txt");
            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();
        }
    }
}

ObjectInputStream & ObjectOutputStream

//Object流
public class TestObjectIO {
    public static void main(String[] args) {
        T t = new T();
        t.k = 90;
        try {
            FileOutputStream fos = new FileOutputStream("F:/DB/objectio.dat");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(t);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("F:/DB/objectio.dat");
            ObjectInputStream ois = new ObjectInputStream(fis);
            T tRead = (T) ois.readObject();
            System.out.println(tRead.i + " " + tRead.j + " " + tRead.d + " " + tRead.k);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class T implements Serializable{
    int i = 10;
    int j = 9;
    double d = 3.4;
    transient int k = 40; //序列化的時候不序列化該變量
}