IO流（字符流，对象的序列化和反序列化）

二、字符流

1. 编码问题
2. 文本和文本文件：
   JAVA中的文本(char)是16位无符号整数，是字符的unicode编码（双字节编码），文件是byte、byte、byte…的数据序列。
   文本文件是文本(char)序列按照某种编码方案(utf-8、utf16-be、gbk)序列化为byte的存储结果
3. 字符流也包括输入流和输出流(reader、writer)。字符的处理，一次处理一个字符，字符的底层仍然是基本的字节序列。
4. 字符流的基本实现：
   InputStreamReader：完成byte流解析为char流，按照编码解析
   OutputStreamWriter：提供char流到byte流，按照编码处理
   FileReader/FileWriter：是对文件进行操作
   字符流的过滤器：
   BufferedReader——>readLine：一次读一行
   BufferedWriter——>PrintWriter：一次写一行

InputStreamReader / OutputStreamWriter

public class IsrAndOswDemo {
    
    
    public static void main(String[] args)throws IOException {
    
    
        FileInputStream in = new FileInputStream("D:\\code\\IO\\demo\\最开始.txt");
        InputStreamReader isr = new InputStreamReader(in,"utf-8");//默认项目的编码,操作的时候，要写文件本身的编码格式

        FileOutputStream out = new FileOutputStream("D:\\code\\IO\\demo\\空白文本.txt");
        OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
		/*int c ;
		while((c = isr.read())!=-1){
			System.out.print((char)c);
		}*/
        char[] buffer = new char[8*1024];
        int c;
		/*批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
		  返回的是读到的字符的个数
		*/
        while(( c = isr.read(buffer,0,buffer.length))!=-1){
    
    
            String s = new String(buffer,0,c);
            System.out.print(s);
            osw.write(buffer,0,c);
            osw.flush();
        }
        isr.close();
        osw.close();
    }
}
/*输出：
这是最开始的文本
Process finished with exit code 0
*/

FileReader / FileWriter

public class FrAndFwDemo {
    
    
    public static void main(String[] args) throws IOException{
    
    
        FileReader fr = new FileReader("D:\\code\\IO\\demo\\最开始.txt");
        FileWriter fw = new FileWriter("D:\\code\\IO\\demo\\空白文本.txt");
        //FileWriter fw = new FileWriter("e:\\javaio\\imooc2.txt",true);
        char[] buffer = new char[2056];
        int c ;
        while((c = fr.read(buffer,0,buffer.length))!=-1){
    
    
            fw.write(buffer,0,c);
            fw.flush();
        }
        fr.close();
        fw.close();
    }
}
/*输出：

Process finished with exit code 0
*/

BufferedReader / BufferedWriter

public class BrAndBwOrPwDemo {
    
    
    public static void main(String[] args) throws IOException{
    
    
        //对文件进行读写操作
        BufferedReader br = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("D:\\code\\IO\\demo\\最开始.txt")));
		/*BufferedWriter bw = new BufferedWriter(
				new OutputStreamWriter(
						new FileOutputStream("e:\\javaio\\imooc3.txt")));*/
        PrintWriter pw = new PrintWriter("D:\\code\\IO\\demo\\空白文本.txt");
        //PrintWriter pw1 = new PrintWriter(outputStream,boolean autoFlush);
        String line ;
        while((line = br.readLine())!=null){
    
    
            System.out.println(line);//一次读一行，并不能识别换行
			/*bw.write(line);
			//单独写出换行操作
			bw.newLine();//换行操作
			bw.flush();*/
            pw.println(line);
            pw.flush();
        }
        br.close();
        //bw.close();
        pw.close();
    }
}
/*输出：
大蝴蝶
打虎队
等会我
的武器
到琼海

Process finished with exit code 0
*/

三、对象的序列化和反序列化

1. 对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化
2. transient关键字加上（private transient int stuage;），则该元素不会进行虚拟机jvm默认的序列化，但是可以自己完成该元素的序列化。
3. 一个类实现了序列化接口，那么其子类都可以进行序列化。对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么父类的构造函数会被调用。
4. 序列化流(ObjectOutputStream)，是过滤流，——writerObject
   反序列化流(ObjectInputStream)，——readObject
5. 序列化接口(Serializable)
   对象必须实现序列化接口，才能进行序列化，否则将出现异常。这个接口没有任何方法，只是一个标准。

对象序列化和反序列化

public class ObjectSeriaDemo1 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        String file = "D:\\code\\IO\\demo\\obj.dat";
        
        /*//1.对象的序列化   //编译运行后，会将"10001", "张三", 20写入到obj.dat文件中去
		ObjectOutputStream oos = new ObjectOutputStream(
				new FileOutputStream(file));
		Student stu = new Student("10001", "张三", 20);
		oos.writeObject(stu);
		oos.flush();
		oos.close();*/
		
		//2.对象的反序列化
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(file));
        Student stu = (Student)ois.readObject();
        System.out.println(stu);
        ois.close();

    }
}
/*输出：
Student{stuno='10001', stuname='张三', stuage=20}

Process finished with exit code 0
*/

/*===============================================================*/
public class Student implements Serializable {
    
    
    private String stuno;
    private String stuname;
    private int stuage;

    public Student(){
    
    

    }

    public Student(String stuno, String stuname, int stuage) {
    
    
        super();
        this.stuno = stuno;
        this.stuname = stuname;
        this.stuage = stuage;
    }

    public String getStuno() {
    
    
        return stuno;
    }

    public void setStuno(String stuno) {
    
    
        this.stuno = stuno;
    }

    public String getStuname() {
    
    
        return stuname;
    }

    public void setStuname(String stuname) {
    
    
        this.stuname = stuname;
    }

    public int getStuage() {
    
    
        return stuage;
    }

    public void setStuage(int stuage) {
    
    
        this.stuage = stuage;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "stuno='" + stuno + '\'' +
                ", stuname='" + stuname + '\'' +
                ", stuage=" + stuage +
                '}';
    }
}