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

素颜马尾好姑娘i 2023-06-13 09:27 31阅读 0赞

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