javase—day07

aObjectStream_ObjectInPutStreamDemo02

package com.se.aObjectStream;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * 反序列化的类型：
 * ObjectInputStream(InputStream is)
 *
 * 知识拓展：
 *   1. 序列化时，程序每执行一次都会在开始的地方先写一个流头。如果是追加模式，那么文件中，可能有多个流头
 *   2. 反序列化时，也就是读取文件的时候，默认只读取一次流头，其余都是对象信息，
 *       所以有多个流头，可能是会将除第一个流头以外的流头都读取了为对象信息进行解析
 *   3. 会报异常： java.io.StreamCorruptedException: invalid type code：AC
 */

public class ObjectInPutStreamDemo02 {
    public static void main(String[] args) {
        //创建一个反序列化的流对象
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(
                    new BufferedInputStream(
                            new FileInputStream("./student.s"),4096));
            //反序列化
            Object obj = ois.readObject();
            System.out.println(obj);
        } catch (IOException | ClassNotFoundException  e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

aObjectStream_ObjectOutPutStreamDemo01

package com.se.aObjectStream;

import java.io.*;
import java.util.Objects;

/**
 * 序列化： 内存中的对象转成字节数组，这个过程就是序列化，序列化的目的是存储或者传输
 * 反序列化： 字节数组转成内存中的对象，这个过程就是反序列化，反序列化的目的是读取或者传输
 * <p>
 * tips： 字节数组就是字节序列的意思
 * 序列化：ObjectOutputStream
 */

public class ObjectOutPutStreamDemo01 {
    public static void main(String[] args) {
        //创建一个学生
        Student student = new Student("小米", 18, '男');
        //使用对象输出流，将学生写出文件中
        ObjectOutputStream ois = null;
        try {
            ois = new ObjectOutputStream(
                    new BufferedOutputStream(
                            //流的构造器的相对路径，相对的是Project的根目录
                            new FileOutputStream("./student.s", true), 4096));
            //写出对象

            ois.writeObject(student);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/*
  自定义的类型，如果想要将其对象进行存储或者传输，那么这个类必须要实现一个接口
  这个接口就是Serializable
  该接口里面什么的没有东西，就是标识，标识这个类是可以被序列化的

  seraiVersionUID：序列化的版本号
    1. 在序列化时，系统会默认给该类提供一个序列化版本号。
    当反序列化时，系统会先读取该类的序列化版本号，然后与反序列化版本号进行比较，
    如果版本号相同，则认为两个版本是相同的，可以进行反序列化。
    如果版本号不同，则认为两个版本是不同的，不能进行反序列化，报异常，版本不兼容

    注意： 系统提供的版本号，可能会发生变化，不同时间点的序列化版本号可能不同
    2. 为了避免上述情况，程序员应该主动提供一个固定的版本号
       这样序列化和反序列化的版本号是相同的，就不错出现异常

 */
class Student implements Comparable<Student>, Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;
    private char gender;

    public Student() {
    }

    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) return true;
        if (object == null || getClass() != object.getClass()) return false;
        Student student = (Student) object;
        return age == student.age && gender == student.gender && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, gender);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    @Override
    public int compareTo(Student o) {
        return o.age - this.age;
    }
}

aObjectStream_ObjectOutPutStreamDemo02

package com.se.aObjectStream;

import java.io.*;
import java.util.Objects;

public class ObjectOutPutStreamDemo02 {
    public static void main(String[] args) {
        // 创建对象
        Teacher t = new Teacher("张三", 18, "北京", "我是备注");
        //序列化Teacher对象
        serialObject(t);

        // 反序列化对象并打印
        Teacher t1 = deserializeTeacher();
        System.out.println(t1);

    }

    //序列化对象
    public static void serialObject(Object obj) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(
                    new BufferedOutputStream(
                            new FileOutputStream("./teacher.txt"), 4096));
            oos.writeObject(obj);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //反序列化对象
    public static Teacher deserializeTeacher() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(
                    new BufferedInputStream(
                            new FileInputStream("./teacher.txt"), 4096));
            //读取对象
            Object obj = ois.readObject();
            if (obj instanceof Teacher) {
                return (Teacher) obj;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return null;
    }

}

class Teacher implements Serializable, Comparable<Teacher> {
    public static final long serialVersionUID = 1L;

    private String name;
    private int age;
    private String address;
    private transient String remark;

    public Teacher() {

    }

    public Teacher(String name, int age, String address, String remark) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.remark = remark;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) return true;
        if (object == null || getClass() != object.getClass()) return false;
        Teacher teacher = (Teacher) object;
        return age == teacher.age && address == teacher.address && Objects.equals(name, teacher.name) && Objects.equals(remark, teacher.remark);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, address, remark);
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }


    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                ", remark='" + remark + '\'' +
                '}';
    }

    @Override
    public int compareTo(Teacher o) {
        return 0;
    }
}

bWriterAndReader_01WriterDemo

package com.se.bWriterAndReader;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 字符输出流：
 * 1. 抽象父类 Writer
 * 2. 书写底层，以一个char为单位
 * 3. 底层依然是字节流
 * 4. 基本的字符流，我们称为转换流，因为涉及到字符与字节之间的转换所使用的编码集
 * 5. 在编写时的字符集，默认使用的是UTF-8， 字母是一个字节，汉字是三个字节。
 * 6. OutputStreamWriter(OutputStream os)
 *     OutputStreamWriter(OutputStream os, String charsetName)
 */

public class _01WriterDemo {
    public static void main(String[] args) {
        OutputStreamWriter osw = null;
        try {
            osw = new OutputStreamWriter(
                    //常用的字符集编码 UTF-8 GBK GB2312 GB18030 UNICODE
                    //ISO-8859-1: HTTP通信时使用
                    new FileOutputStream("./test07/char.txt"));
            //写一个字符
            osw.write("中");
            //写一个字符组
            char[] chars = {'国', '欢', '迎', '你'};
            osw.write(chars);
            //将chs中的后三个再写一次
            osw.write(chars, chars.length - 3, 3);
            //将一个字符串写出
            osw.write("你好");
            //如果有缓冲，冲刷，强制写出
            osw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                osw.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

bWriterAndReader_02ReaderDemo

package com.se.bWriterAndReader;

import java.io.*;

/**
 * 字符转换输入流：
 *    InputStreamReader(InputStream os)
 *    InputStreamReader(InputStream os,String charsetname)
 */

public class _02ReaderDemo {
    public static void main(String[] args) {
        InputStreamReader isr = null;
        try {
            isr = new InputStreamReader(
                    new FileInputStream("./test07/char.txt"), "GB2312");
            //读取一个字符
            for (int i = 0; i < 6; i++) {
                char ch = (char) isr.read();
                System.out.println("ch:" + ch);
            }
            //继续读取10个字符
            char[] chs = new char[10];
            int len;
            while ((len = isr.read(chs)) != -1) {
                System.out.println("chs:" + new String(chs, 0, len));
                System.out.println("len:" + len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

cBufferedChar_01PrintWrierDemo

package com.se.cBufferedChar;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * 缓冲字符输出流：
 *   1. 一般使用PrintWriter这个子类，不适用BufferedWriter
 *   2. PrintWriter这个类的构造器比较丰富
 *        -PrintWriter(File file)
 *        -PrintWriter(String pathname)
 *        -PrintWriter(OutputStream os)
 *        -PrintWriter(OutputStream os,boolean autoFlush)
 *        -PrintWriter(Writer writer)
 *        -PrintWriter(Writer writer,boolean autoFlush)
 *   3. 内部也是维护了一个字符缓冲区
 *       写的时候，先写到缓冲区，缓冲区满了再一次性写入文件
 *       不过，当使用的自动行刷新功能，每写一行，然后在行尾添加换行符，强制写出
 *   4. 除了write方法，还提供了print和println的各种重载方法
 */

public class _01PrintWriterDemo {
    public static void main(String[] args) {
        try (PrintWriter pw = new PrintWriter(
                new OutputStreamWriter(
                        new FileOutputStream("test07/char.txt"),"GBK"),true)){
            //写出一个字符数组
            char[] charArray = "你好，中国".toCharArray();
            pw.write(charArray);

            //调用print方法，写出去"请从绝处"
            pw.print("请从绝处");//print 没有行刷新效果

            //调用println方法，写出去"读我侠义"
            //当构造器里面指定行刷新功能，设定为true，此时println才会在行尾添加换行符，强制写出
            pw.println("读我侠义");

            Thread.sleep(30000);

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

cBufferedChar_02BufferedReaderDemo

package com.se.cBufferedChar;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * 字符缓冲流
 * 1. 内部也提供了一个缓冲区，尽可能一次性读取，存满缓存区。
 * 2. 程序员调用读取方法，从缓冲区中获取数据，当获取完数据后，缓冲区再次从文件中尽可能一次性读取数据
 * 3. BufferedReader(Reader reader)
 * 4. 常用方法是readline(): 读取一行数据，只读取到换行符，但是读取的数据不含换行符
 */

public class _02BufferedReaderDemo {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("test07/char.txt"), "GBK"))) {
            char ch = (char) br.read();
            System.out.println("ch:" + ch);

            // 读取一行数据
            String s;
            while ((s = br.readLine()) != null) {
                System.out.println("s:" + s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

cBufferedChar_03FileWriterDemo

package com.se.cBufferedChar;

import java.io.FileWriter;

/**
 * FileWriter: 文件输出流
 *  1. 相当于OutputStreamWriter和FileOutputStream的组合，但是不能指定字符集
 *  2. 构造器：
 *      FileWriter(File file)
 *      FileWriter(String file，boolean append)
 *      FileWriter(String pathname)
 *      FileWriter(String pathname，boolean append)
 *   3. 常用方法： 就是转换流的方法
 */

public class _03FileWriterDemo {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("./test07/char.txt")) {
            fw.write("有时明月无人夜");
            fw.write("独向昭潭制恶龙");
            // 追加
            fw.append("请从绝处，读我侠义");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

cBufferedChar_04FileReaderDemo

package com.se.cBufferedChar;

import java.io.FileReader;

/**
 * 文件输出流: FileReader
 *  1. 相当于InputStreamReader和FileInputStream的组合，不能指定字符集
 *  2. 构造器：
 *       FileReader(File file)
 *       FileReader(String fileName)
 *  3. 常用方法：也与转换流一致
 */

public class _04FileReaderDemo {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("test07/char.txt")) {
            int ch = fr.read();
            System.out.println((char) ch);

            char[] chs = new char[100];
            int len = -1;
            while ((len = fr.read(chs)) != -1) {
                System.out.println(new String(chs, 0, len));
                System.out.println(len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

dOher_01SystemDemo

package com.se.dOther;

import java.io.*;
import java.util.Scanner;

/**
 * system: 系统类，里面封装了一些本地方法和静态属性
 *  1. 静态属性：
 *       PrintStream out: 标准输出流，默认目的地是控制台console
 *       PrintStream err: 标准错误输出流，默认目的地是控制台console
 *       InputStream in: 标准输入流，默认数据源是控制台console
 */

public class _01SystemDemo {
    public static void main(String[] args) throws IOException {
       testSystemIn();
    }

    /**
     * 测试System.in
     * @throws IOException
     */
    public static void testSystemIn() throws IOException {
        //将Sysyem.in临时报错到一个变量中
        InputStream is = System.in;
        FileInputStream fis = new FileInputStream("test07/char.txt");
        //将数据源从控制台来为指定文件
        System.setIn(fis);
        //使用扫描类
        Scanner sc = new Scanner(System.in);
        //与迭代器类似，先问是否有下一行
        while (sc.hasNext()){
            //取一行数据
            String s = sc.nextLine();
            System.out.println(s);
        }

    }

    /**
     * 测试System.out
     * @throws FileNotFoundException
     */
    public static void testSystemOut() throws FileNotFoundException {
        /**
         * System.out： 返回一个标准输出流对象
         *  调用println方法： 即调用的是PrintStream的方法，将数据打印到控制台
         */
        System.out.println("hello world");
        /*
          修改out这个流的目的地。
          1. 将默认的目的地，临时保存起来
         */
        PrintStream ps = System.out;
        //使用IO流，来重新定位
        PrintStream pw = new PrintStream("test07/char.txt");
        //将上述的流对象，赋值给System的out属性
        System.setOut(pw);
        //调用out的println方法，将数据打印到文件
        System.out.println("哈基米");

        //改回
        System.setOut(ps);
        System.out.println("i'm back");
    }
}

zExercise_Exercise01

package com.se.zExercise;

import java.io.*;

public class Exercise01 {
    public static void main(String[] args) {
        // 测试1： 调用copyFile1方法，copy一个纯文本文件
        copyFile1(new File("./dir11/a.txt"), new File("./dir11/a.txt"));

        // 测试2： 调用copyFile1方法，copy一个视频文件
        copyFile1(new File("./dir11/a.mp4"), new File("./dir11/b.mp4"));

        // 测试3： 调用copyFile2方法，copy一个纯文本文件
        copyFile2(new File("./dir12/a.txt"), new File("./dir12/a.txt"));

        // 测试4： 调用copyFile2方法，copy一个视频文件
        copyFile2(new File("./dir12/a.mp4"), new File("./dir12/b.mp4"));
    }

    public static void copyFile1(File fromFile, File toFile) {
        try (FileInputStream fis = new FileInputStream(fromFile);
             FileOutputStream fos = new FileOutputStream(toFile);
             BufferedInputStream bis = new BufferedInputStream(fis);
             BufferedOutputStream bos = new BufferedOutputStream(fos)) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = bis.read(buffer)) > 0) {
                bos.write(buffer, 0, length);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void copyFile2(File fromFile, File toFile) {
        try (FileReader fr = new FileReader(fromFile);
             FileWriter fw = new FileWriter(toFile)) {
            char[] buffer = new char[1024];
            int length;
            while ((length = fr.read(buffer)) > 0) {
                fw.write(buffer, 0, length);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}