IO Reader、Writer：字符流读写类

java

• 字符流读取字符，先读取到字节数组，然后转为字符
• 字符流写出字符，需要把字符转为字节再写出
• 只能是操作文本文件
• 不可以拷贝非文本文件
• 写出的时候会有一个小缓冲区 2k
• 如果复制文本文件，不建议使用字符流

Reader：字符流读取

public class Test1_Reader {
    public static void main(String[] args) throws Exception {
            FileReader fr = new FileReader("E:/JavaTaskIO/123.txt");
            int len = -1;
            while((len=fr.read())!=-1){
                System.out.print((char)len);
            }
            fr.close();
    }
}

Writer：字符流写出

public class Test2_Writer {
    public static void main(String[] args) throws Exception {
        FileWriter fw = new FileWriter(new File("E:/JavaTaskIO/456.txt"));
        fw.write("我是新添加的。");
        fw.write("helloword");
        fw.close();
    }
}

FileRWCopy：拷贝（不建议使用）

public class Test_FileRWCopy {
    public static void main(String[] args) throws Exception {
        //创建一个读入字符流
        FileReader fr = new FileReader("E:/JavaTaskIO/fr.doc");
        //创建一个写出的字符流
        FileWriter fw = new FileWriter(new File("E:/JavaTaskIO/fw.doc"));
        int len = -1;
        while((len=fr.read())!=-1){
            fw.write(len);
        }
        fr.close();
        fw.close();     
    }
}

自定义缓存区

public class Test4_FileWRBuffer {
    public static void main(String[] args) throws Exception {
        // 创建一个读入字符流
        FileReader fr = new FileReader("E:/JavaTaskIO/123.txt");
        // 创建一个写出的字符流
        FileWriter fw = new FileWriter(new File("E:/JavaTaskIO/123.doc"));
        char[] buffer = new char[1024 * 200];// 自定义缓冲
        int len = 0;
        while ((len = fr.read(buffer)) != -1) {
            fw.write(buffer, 0, len);
        }
        fr.close();
        fw.close();
    }
}

系统缓存区

public class Test5_BufferWR {
    public static void main(String[] args) throws Exception {
        // 创建一个读入字符流
        FileReader fr = new FileReader("E:/JavaTaskIO/123.txt");
        // 创建一个写出的字符流
        FileWriter fw = new FileWriter(new File("E:/JavaTaskIO/789.doc"));
        //创建一个带缓冲区的字符输入流
        BufferedReader br = new BufferedReader(fr);
    //创建一个带缓冲区的字符输入流                    修改缓存区大小
        BufferedWriter bw = new BufferedWriter(fw,1024*200);
        int len = -1;
        while((len = br.read())!=-1){
            bw.write(len);
        }
        br.close();
        bw.close();
    }
}

行读字符

public class Test_行读代码 {
    public static void main(String[] args) throws Exception {
        // 创建一个读入字符流
        FileReader fr = new FileReader("E:/JavaTaskIO/444.txt");
        // 创建一个写出的字符流
        FileWriter fw = new FileWriter(new File("E:/JavaTaskIO/555.txt"));
        // 创建一个带缓冲区的字符输入流
        BufferedReader br = new BufferedReader(fr);
        // 创建一个带缓冲区的字符输入流
        BufferedWriter bw = new BufferedWriter(fw);
        String line = null;
        //br.readLine() 一行一行读
        while ((line = br.readLine()) != null) {
            bw.write(line);
            //bw.write("\r\n");//\r 回车 (windows)换行
            bw.newLine();//(跨平台)换行
        }
        br.close();
        bw.close();
    }
}

反转输出_字符流

public class Test_反转输出_字符流 {
    /*
     * 复制一个文件，原来是第一行，复制后变成最后一行
     * */
    public static void main(String[] args) throws Exception {
        /*
         * File file = new File("E:/JavaTaskIO/444.txt");
         * FileReader fr = new FileReader(file);
         * BufferefReader br = new BufferefReader(fr);
         * */
        // 创建一个带缓冲区的字符输入流  
        BufferedReader br = new BufferedReader(new FileReader(new File("E:/JavaTaskIO/444.txt")));
        // 创建一个带缓冲区的字符输入出流    
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("E:/JavaTaskIO/666.txt")));
        String line = null;
        List<String> list = new ArrayList<String>();
        while ((line = br.readLine()) != null) {
            list.add(line);
        }
        for(int i =list.size()-1;i>=0;i--){
            bw.write(list.get(i));
            bw.newLine();
        }
        br.close();
        bw.close();
    }
}

InputStreamReader && OutputStreamWriter

public class Test1_IOStreamRW {
    public static void main(String[] args) throws Exception {
        // 将字节流转成字符流
        InputStreamReader isr = //输入
                new InputStreamReader
                (new FileInputStream
                (new File("E:/JavaTaskIO/444.txt")),"Gbk");
        OutputStreamWriter osw = //输出
                new OutputStreamWriter
                (new FileOutputStream
                (new File("E:/JavaTaskIO/777.txt")), "GBK");
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.print((char)len);
            osw.write(len);
        }
        isr.close();
        osw.close();
    }
}

ObjectInput(序列化) && OutputStream（反序列化）

• 对对象的持久化存储，就是将自定的对象永久存储
• 这个过程叫序列化，在读出来，叫反序列化
• 被序列化的对象必须实现Serializable接口

public class Test8_ObjectInput_OutputStream {
    public static void main(String[] args) throws Exception {
        ObjectOutputStream oos =  //写入
                new ObjectOutputStream
                (new FileOutputStream
                (new File("E:/JavaTaskIO/ios.txt")));
        Student student = new Student("张三", 16);
        oos.writeObject(student);
        oos.close();
        ObjectInputStream ois =  //读出
                new ObjectInputStream
                (new FileInputStream
                (new File("E:/JavaTaskIO/ios.txt")));
        Student student2 = (Student) ois.readObject();
        System.out.println(student2);
        ois.close();
    }
}