（java总结）序列换、反序列化、打印流

package Demo46;

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

/**
 * java.io.ObjectInputStream extends InputStream
 * ObjectInputStream:对象的反系列化流
 * 作用：把文件中保存的对象，以流的方式读取出来使用
 * 构造方法：
 *      ObjectInputStream(InputStream in)创建写入指定InputStream的ObjectInputStream
 *      参数：
 *          InputStream in:字节输入流
 * 特有的成员方法：
 *      void ReadObject(Object obj)从ObjectInputStream读取对象
 * 使用步骤：
 *      1、创建ObjectInputStream对象，构造方法中传递字节输入流
 *      2、使用ObjectInputStream对象中的方法ReadObject,读取保存对象的文件
 *      3、释放资源
 *      4、使用读取出来的对象
 *readObject方法声明抛出ClassNotFoundException(文件找不到异常)
 * 当不存在对象的class文件是抛出异常
 * 反序列化的前提：
 *      1、类必须实现serializable
 *      2、必须存在类对应的class文件
 */
public class DemoObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、创建ObjectInputStream对象，构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        // 2、使用ObjectInputStream对象中的方法ReadObject,读取保存对象的文件
        Object o = ois.readObject();
        //3、释放资源
        ois.close();
        //4、使用读取出来的对象
        System.out.println(o);

    }
}

package Demo46;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/**
 * java.io.ObjectOutputStream extends OutputStream
 * ObjectOutputStream:对象的系列化流
 * 作用：把对象以流的方式写入到文件中保存
 *
 * 构造方法：
 *      ObjectOutputStream(OutputStream out)创建写入指定OutputStream的ObjectOutputStream
 *      参数：
 *          OutputStream out:字节输出流
 *特有的成员方法：
 *      void writeObject(Object obj)将指定的对象写入ObjectOutputStream
 *
 * 使用步骤：
 *      1、创建ObjectOutputStream对象，构造方法中传递字节输出流
 *      2、使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
 *      3、释放资源
 */
public class DemoObjectOutputStream {
    public static void main(String[] args) throws IOException {
        // 1、创建ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        //2、使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
        oos.writeObject(new Person("美女",18));
        //3、释放资源
        oos.close();
    }
}

package Demo46;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * java.io.InputStreamReader extends Reader
 * InputStreamReader是字节流通向字符流的桥梁，可以使用指定的charset将要写入流中的字符编码成字节
 *
 * 继承自父类的共性的成员方法：
 *          int read()读取单个字符并返回
 *          int read(char[] cbuf)一次读取多个字符，将字符读入数组
 *          void close()关闭流并释放资源
 *构造方法：
 *      InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
 *      InputStreamReader(InputStream in, String charsetName)创建一个使用指定字符集的InputStreamReader
 *      参数：
 *          InputStreamReader in：字节输入流，用来读取文件中保存的字节
 *          String charsetName：指定编码表的名称，不区分大小写
 *使用步骤：
 *      1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
 *      2、使用InputStreamReader对象中的方法read读取文件
 *      3、释放资源
 *注意事项：
 *      构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码
 */
public class DemoOutputStreamReader {
    public static void main(String[] args) throws IOException {
        //reader_utf_8();
        reader_gbk();

    }

    private static void reader_gbk() throws IOException {
        // 1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader ipRead = new InputStreamReader(new FileInputStream("E:\\hadoop\\testfile\\abc.txt"),"gbk");

        //  2、使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = ipRead.read())!=-1){
            System.out.println((char)len);
        }
        //3、释放资源
        ipRead.close();
    }

    private static void reader_utf_8() throws IOException {
        // 1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader ipRead = new InputStreamReader(new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"utf-8");

        //  2、使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = ipRead.read())!=-1){
            System.out.println((char)len);
        }
        //3、释放资源
        ipRead.close();

    }
}

package Demo46;

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

/**
 * java.io.OutputStreamWriter extends writer
 * OutputStreamWriter:是字符流通向字节流的桥梁，可以使用指定的charset将要写入流中的字符编码成字节
 *
 * 继承自父类的共性的方法：
 *     void write(int c)写入单个字符
 *     void write(char[] cbuf)写入字符数组
 *     abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分，off数组的开始索引，len写的字符个数
 *     void write(String str)写入字符串
 *     void write(String str, int off, int len)写入字符串的某一部分，off字符串的开始索引，len写的字符串的个数
 *     void flush()刷新该流的缓冲
 *     void close()关闭此流，但要先刷新它
 *
 * 构造方法：
 *      OutputStreamWriter(OutputStream out)创建使用默认字符编码的OutputStreamWriter
 *      OutputStreamWriter(OutputStream out, String charsetName)创建字符集的指定的OutputStreamWriter
 *      参数：
 *          OutputStream out:字节输出流，可以用来写转换之后的字节到文件中
 *          String charsetName:指定的编码表名称，不区分大小写，可以是utf-8/UTF-8/GBK,不指定默认使用UTF-8
 *使用步骤：
 *      1、创建一个OutputStreamWriter对象构造方法中传递字节输出流和指定的编码表名称
 *      2、使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中
 *      3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区的字节刷新到文件中
 *      4、释放资源
 *
 */
public class DemoOutputStreamWriter {
    public static void main(String[] args) throws IOException {
      //write_utf_8();
      write_gbk();

    }

    private static void write_gbk() throws IOException {
        //1、创建一个OutputStreamWriter对象构造方法中传递字节输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"gbk");
        //2、使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中
        osw.write("你好");
        //3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区的字节刷新到文件中
        osw.flush();
        //4、释放资源
        osw.close();
    }

    //使用转换rea流OutputStmWriter写UTF-8格式的文件
    private static void write_utf_8() throws IOException {
        //1、创建一个OutputStreamWriter对象构造方法中传递字节输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"utf-8");
        //2、使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中
        osw.write("你好");
        //3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区的字节刷新到文件中
        osw.flush();
        //4、释放资源
        osw.close();
    }
}

package Demo46;

import java.io.*;

/**
 * 练习：转换文件编码：
 *      将GBK编码的文本文件，转换为UTF-8编码的文本文件
 *分析：
 *     1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称GBK
 *     2、创建OutputStreamReader对象，构造方法中传递字节输出流和指定的编码表名称utf-8
 *     3、使用InputStreamReader对象中的方法read读取文件
 *     4、使用OutputStreamWriter对象中的方法write，把读取的数据写入文件中
 *     5、释放资源
 *
 */
public class Test {
    public static void main(String[] args) throws IOException {
        //1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称GBK
        InputStreamReader input = new InputStreamReader(new FileInputStream("E:\\hadoop\\testfile\\abc.txt"),"gbk");
        //2、创建OutputStreamReader对象，构造方法中传递字节输出流和指定的编码表名称utf-8
        OutputStreamWriter ouput = new OutputStreamWriter(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"utf-8");
        // 3、使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = input.read())!=-1){
            //4、使用OutputStreamWriter对象中的方法write，把读取的数据写入文件中
            ouput.write(len);
        }
        //5、释放资源
        ouput.close();
        input.close();

    }
}

package Demo46;

import java.io.Serializable;

/**
 * 序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
 * 类通过实现java.io.serializable 接口以启用其序列化功能，未实现此接口的类将无法使用其任何状态序列化或反序列化
 * serializable接口也叫标记型接口
 *      要进行序列化和反序列化的类必须实现serializable接口，就会给类添加一个标记
 *      当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记
 *      有：可以实现序列化和反序列化
 *      没有：则会抛出异常NotSerializableException
 *
 *static关键字：静态关键字
 *     静态优于非静态加载到内存中,所以被static修饰的成员变量不能被序列化的，序列化的都是对象
 *transient关键字：瞬态关键字
 *      被 transient修饰的成员变量，不能被序列化
 *      不想被序列化就用transient修饰
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private  int age;
    // private  transient int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

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

package Demo46;

import java.io.*;
import java.util.ArrayList;

/**
 * 练习：序列化集合
 *      对集合进行序列化和反序列化
 * 分析：
 *      1、定义一个存储Person对象的ArrayList集合
 *      2、在ArrayList集合对象存储Person对象
 *      3、创建一个序列化流ObjectOutputStream对象
 *      4、使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
 *      5、创建一个反序列化ObjectOutputStream对象
 *      6、使用ObjectOutputStream对象中的方法readObject读取文件中保存的集合
 *      7、把Object类型的集合转换为ArrayList类型
 *      8、遍历ArrayList集合
 *      9、释放资源
 */
public class Test1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、定义一个存储Person对象的ArrayList集合
        ArrayList<Person> list = new ArrayList<>();

        //2、在ArrayList集合对象存储Person对象
        list.add(new Person("迪丽热巴",18));
        list.add(new Person("马尔扎哈",19));
        list.add(new Person("景甜",15));

        //3、创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream ows = new ObjectOutputStream(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        //4、使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
        ows.writeObject(list);

        //5、创建一个反序列化ObjectOutputStream对象
        ObjectInputStream ofs = new ObjectInputStream(new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        //6、使用ObjectOutputStream对象中的方法readObject读取文件中保存的集合
        Object o = ofs.readObject();

        //7、把Object类型的集合转换为ArrayList类型
        ArrayList<Person> list2 = (ArrayList<Person>)o;
        //8、遍历ArrayList集合
        for (Person person : list2) {
            System.out.println(person);
        }
        //9、释放资源
        ofs.close();
        ows.close();
    }
}

package Demo46;

import java.io.FileNotFoundException;
import java.io.PrintStream;

/**
 * java.io.PrintStream:打印流
 *      PrintStream ：为其它输出流添加了功能，是它们能够方便的打印各种数据值表示形式
 * PrintStream特点：
 *      1、只负责数据的输出，不负责数据的读取
 *      2、与其它输出流不同，PrintStream永远不会抛出IOException
 *      3、特有的方法print,println
 *              void print(任意类型的值)
 *              void println(任意类型的值并换行)
 *构造方法：
 *      PrintStream(File file):输出的目的地是一个文件
 *      PrintStream(OutputStream out):输出的目的地是一个字节输出流
 *      PrintStream(String fileName):输出的目的地是一个文件路径
 * PrintStream extends OutputStream
 * 继承自父类的成员方法：
 *      public void close():关闭此流释放资源
 *      public void flush():刷新此输出流并强制任何缓冲的输出字节被写出
 *      public void write(byte[] b):将b.length字节数组写入此输出流中
 *      public void write(byte[] b, int off, int len):将指定的字节数组写入len字节,从偏移量off开始输出到此输出流
 *      public abstract void write(int b)：将指定的字节输出流
 *
 * 注意：
 *      如果使用继承自父类的write方法写数据，那么查看数据的时候回查询编码表97 ->a
 *      如果使用自己特有的方法print/println方法写数据，写的数据原样输出97 -> 97
 *
 * 可以改变输出语句的目的地
 * static void setOut(printStream out)
 */
public class DemoPrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("我在控制台输出");
        //创建打印流printStream对象，构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("E:\\daima\\java_day01\\src\\Demo44\\abc");


        System.setOut(ps);
        System.out.println("我在打印流输出");
        //  如果使用继承自父类的write方法写数据，那么查看数据的时候回查询编码表97 ->a
        ps.write(97);
        //如果要使用自己特有的方法print/println方法写数据，写数据原样输出97->97
        ps.println(97);
        ps.println(8.8);
        ps.println("hello");
        ps.close();
    }
}