day17-缓冲流&转换流&序列化流&打印流&Properties（二）

OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
把字节流转换为字符流。
转换流 <==> 字符流 = 字节流 + 编码表。

/*
   * 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
   * 在计算机中中文的存储分两个字节：
   *    第一个字节肯定是负数。
   *    第二个字节常见的是负数，可能有正数。但是没影响。
   */
    public static void main(String[] args) {
//       String s = "abcde";
      //[97, 98, 99, 100, 101]  正数不拼
      String s = "我爱你中国";//因为当前我的编码是utf-8 是占三个字节的
      // [-26, -120, -111, -25, -120, -79, -28, -67, -96, -28, -72, -83, -27, -101, -67]  负数拼
      byte[] bys = s.getBytes();
      System.out.println(Arrays.toString(bys));
    }
  }

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

public class ReaderDemo2 {
  public static void main(String[] args) throws IOException {
    // 创建对象
    // InputStreamReader isr = new InputStreamReader(new FileInputStream(
    // "osw.txt"));
    // InputStreamReader isr = new InputStreamReader(new FileInputStream(
    // "osw.txt"), "GBK");
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
        "osw.txt"), "UTF-8");
    // 读取数据
    // 一次读取一个字符
    int ch = 0;
    while ((ch = isr.read()) != -1) {
      System.out.print((char) ch);
    }
    // 释放资源
    isr.close();
  }
}

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

/*
 * OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
 * OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
 * 把字节流转换为字符流。
 * 字符流 = 字节流 +编码表。
 */
public class OutputDemo {
    public static void main(String[] args) throws IOException {
        // 定义文件路径
        String FileName = "E:\\out.txt";
        // 创建流对象,默认UTF8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
        // 写出数据
        osw.write("你好"); // 保存为6个字节
        String encoding = osw.getEncoding();
        System.out.println(encoding);//UTF8
        osw.close();
        System.out.println("================");
    // 定义文件路径
    String FileName2 = "E:\\out2.txt";
      // 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 写出数据
        osw2.write("你好");// 保存为4个字节
        String encoding1 = osw2.getEncoding();
        System.out.println(encoding1);//GBK
        osw2.close();
    }
}

public class TransDemo {
    public static void main(String[] args) throws IOException {
        //编码，你好 转成 字节 utf-8 3个字
        //解码，utf-8 3个字
        //解码，3个字节解，GBK只解到2个字节，所以就出现了乱码问题
        //我们在使用转换流时，一定要注意读和写的字符编码一保持一致
        //读 GBK    占两个字节
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");
        //写 ide中的 utf-8   占三个字节
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
        //复制
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            osw.write(chs,0,len);
        }
        isr.close();
        osw.close();
    }
}

public static void main(String[] args) throws IOException {
        //基本字节流   构造方法参数 是  路径字符串/File
        FileOutputStream fs = new FileOutputStream("a.txt");
        FileInputStream fis = new FileInputStream("a.txt");
        //基本字符流
        FileWriter fw = new FileWriter("a.txt");
        FileReader fr = new FileReader("a.txt");
        //缓冲字节流  构造方法参数时基本流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
        //缓冲字符流
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        //转换输出流  字符流   构造方法参数时基本流对象 +字符集
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8");
        //转换输入流  字符流
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
    }

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

/**
 * 序列化： 把对象以流的形式进行流化，存储或者在网络中转输        对象 --- 流数据 ObjcetOutputStream
 * 返序列化： 把文本中的数据据以流的形式进行还原成对象            流数据---对象   ObjectInPutStream
 * 
 * 帮助理解：
 *      序列化：将 Java 对象转换成字节流的过程。
 *      反序列化：将字节流转换成 Java 对象的过程。
 */
public static void main(String[] args) throws IOException, ClassNotFoundException {
    // 由于我们要对对象进行序列化，所以我们先自定义一个类
    // 序列化数据其实就是把对象写到文本文件
    write();//序列化
    // read();//反序列化
}
private static void read() throws IOException, ClassNotFoundException {
    // 创建反序列化对象
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
            "oos.txt"));
    // 还原对象
    Object obj = ois.readObject();
    // 释放资源
    ois.close();
    // 输出对象
    System.out.println(obj); //Person{name='江一燕', age=27}
}
private static void write() throws IOException {
    // 创建序列化流对象
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
    // 创建对象
    Person p = new Person("江一燕", 27);
    // public final void writeObject(Object obj) 
    oos.writeObject(p); //把对象写入到序列化流中，需要Person实现Serializable接口
    // 释放资源
    oos.close();
}
/**
 * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
 * 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
 */
public class Person implements Serializable {
    private String name;
    private int age;
}

//解决办法，给这个类序列化时，给出一个序列号进行绑定
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

/**
 *  注意：
 *     我一个类中可能有很多的成员变量，有些成员变量我不想进行序列化。请问该怎么办呢?
 *        使用transient关键字声明不需要序列化的成员变量
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient int age;//transient不会被序例化

/**
 *  注意：
 *     每一个类中可能有很多的成员变量，有些成员变量我不想进行序列化。请问该怎么办呢?
 *        使用static关键字声明不需要序列化的成员变量
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private static int age;// static不会被序例化

1. 把若干学生对象 ，保存到集合中。
2. 把集合序列化。
3. 反序列化读取时，只需要读取一次，转换为集合类型。
4. 遍历集合，可以打印所有的学生信息

public class SerTest {
    public static void main(String[] args) throws Exception {
        // 创建 学生对象
        Student student = new Student("老王", "laow");
        Student student2 = new Student("老张", "laoz");
        Student student3 = new Student("老李", "laol");
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student2);
        arrayList.add(student3);
        // 序列化操作
        // serializ(arrayList);
        // 反序列化  
        read();
    }
   private static void read() throws IOException, ClassNotFoundException {
        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
        //进行读取出来
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        for(Student s : list){
            System.out.println(s.getName());
            System.out.println(s.getPwd());
        }
    }
    private static void serializ(ArrayList<Student> arrayList) throws Exception {
        // 创建 序列化流 
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        // 写出对象
        oos.writeObject(arrayList);
        // 释放资源
        oos.close();
    }
}