Day23_转换流、序列化流

最新推荐文章于 2023-08-21 10:25:59 发布

BlackTurn

最新推荐文章于 2023-08-21 10:25:59 发布

阅读量91

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_45014721/article/details/115211377

版权

JavaSE 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

文章目录

一、关于编码
二、转换流
三、序列化流
四、transient关键字
五、打印流

一、关于编码

在这里插入图片描述

ASCII编码是美国的用来存储基于英语的电脑编码系统，包含26个大小写英文字符、控制字符（回车键、退格、换行键等）和可显示字符（阿拉伯数字和西文符号）。
GBK编码就是基于中文的，收录了2万个汉字
UTF-8为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码

在这里插入图片描述

二、转换流

1.OutputStreamWriter

字节输入流、字节输出流
FileInputStream extends InputStream
FileOutputStream extends OutputStream

字符输入流、字符输出流
FileReader extends InputStreamReader extends Reader
FileWriter extends OutputStreamWriter extends Writer

你今天要学的是
OutputStreamWriter extends Writer
InputStreamReader extends Reader

为什么要学这个？
你之前学的字符流FileReader可以读取IDE默认编码格式(UTF-8)的文件，但它读取系统默认编码(中文GBK)会产生乱码���
所以我们必须学一个能读取GBK的编码

普通方法：

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/GBK,...不指定默认使用UTF-8

使用步骤:

    使用步骤:
        1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
        2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
        3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        4.释放资源

public class Demo02OutputStreamWriter {
    public static void main(String[] args) throws IOException {
        //write_utf_8();
        write_gbk();
    }

    /*
       使用转换流OutputStreamWriter写GBK格式的文件
    */
    private static void write_gbk() throws IOException {
        //1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\gbk.txt"),"GBK");
        //2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
        osw.write("你好");
        //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        //4.释放资源
        osw.close();
    }

    /*
        使用转换流OutputStreamWriter写UTF-8格式的文件
     */
    private static void write_utf_8() throws IOException {
        //1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
        //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"));//不指定默认使用UTF-8
        //2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
        osw.write("你好");
        //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        //4.释放资源
        osw.close();
    }
}

2.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。
    参数:
        InputStream in:字节输入流,用来读取文件中保存的字节
        String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,...不指定默认使用UTF-8
        
     注意事项:
    构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码

使用步骤:

    1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
    2.使用InputStreamReader对象中的方法read读取文件
    3.释放资源

public class Demo03InputStreamReader {
    public static void main(String[] args) throws IOException {
        //read_utf_8();
        read_gbk();
    }


    /*
        使用InputStreamReader读取GBK格式的文件
     */
    private static void read_gbk() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"GBK");//你好

        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);//必须强转为char类型，因为你读到的是字节byte是数字，必须转为字符你才能看到里面的汉字
        }
        //3.释放资源
        isr.close();
    }

    /*
        使用InputStreamReader读取UTF-8格式的文件
     */
    private static void read_utf_8() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\utf_8.txt"));//不指定默认使用UTF-8
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);//必须强转为char类型，因为你读到的是字节byte是数字，必须转为字符你才能看到里面的汉字
        }
        //3.释放资源
        isr.close();
    }
}

3.转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。
（用读的转换流读取GBK文件，然后用写的转换流把它写成utf-8就OK了）

public class Demo04Test {
    public static void main(String[] args) throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\我是GBK格式的文本.txt"),"GBK");
        //2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\我是utf_8格式的文件.txt"),"UTF-8");
        //3.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            //4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中
            osw.write(len);
        }
        //5.释放资源
        osw.close();
        isr.close();
    }
}

三、序列化流

在这里插入图片描述

1.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 Demo01ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象,构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
        oos.writeObject(new Person("小美女",18));
        //3.释放资源
        oos.close();
    }
}

2.ObjectInputStream反序列化流

java.io.ObjectInputStream extends InputStream
ObjectInputStream:对象的反序列化流
作用:把文件中保存的对象,以流的方式读取出来使用

构造方法:
    ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
    参数:
        InputStream in:字节输入流
特有的成员方法:
    Object readObject() 从 ObjectInputStream 读取对象。

使用步骤:
    1.创建ObjectInputStream对象,构造方法中传递字节输入流
    2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
    3.释放资源
    4.使用读取出来的对象(打印)

 readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)
 当不存在对象的class文件时抛出此异常
 反序列化的前提:
    1.类必须实现Serializable
    2.必须存在类对应的class文件

在这里插入图片描述

public class Demo02ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建ObjectInputStream对象,构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\person.txt"));
        //2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();//此时读取到的o是Object类型

        ois.close();

        System.out.println(o);//Person{name="小美女",age=18}
        Person p = (Person)o;//o是Object类型，我们强制转换为person类型，这就可以调用person的方法了
        System.out.println(p.getName()+p.getAge());//小美女18
    }
}

3.练习：

练习： 	
 	序列化集合
        当我们想在文件中保存多个对象的时候
        可以把多个对象存储到一个集合中
        对集合进序列化和反序列化

public class Demo03Test {
    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("王五",20));
        //3.创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\list.txt"));
        //4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
        oos.writeObject(list);
        //5.创建一个反序列化ObjectInputStream对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\list.txt"));
        //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
        Object o = ois.readObject();
        //7.把Object类型的集合转换为ArrayList类型
        ArrayList<Person> list2 = (ArrayList<Person>)o;
        //8.遍历ArrayList集合
        for (Person p : list2) {
            System.out.println(p);
        }
        //9.释放资源
        ois.close();
        oos.close();
    }
}

在这里插入图片描述

四、transient关键字

    static关键字:静态关键字
        静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
        被static修饰的成员变量不能被序列化的,序列化的都是对象，static的不属于对象因为它被所有对象所共享
        private static int age;//你把age改为static型
        oos.writeObject(new Person("小美女",18));//序列化写入（虽然写的age是18）
        Object o = ois.readObject();//反序列化读出
        Person{name='小美女', age=0}//读出的age为0

    transient关键字:瞬态关键字
        被transient修饰成员变量,不能被序列化
        private transient int age;//你把age改为transient型
        oos.writeObject(new Person("小美女",18));//序列化写入（虽然写的age是18）
        Object o = ois.readObject();//反序列化读出
        Person{name='小美女', age=0}//读出的age为0
       
    所以你以后不想成员被序列化就加上transient关键字

五、打印流

普通方法：

    java.io.PrintStream:打印流
    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) ：将指定的字节输出流。
    特有的方法：
            void print(任意类型的值)
            void println(任意类型的值并换行)        
        
    注意:
        如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
        如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97

构造方法:

        PrintStream(File file):输出的目的地是一个文件
        PrintStream(OutputStream out):输出的目的地是一个字节输出流
        PrintStream(String fileName) :输出的目的地是一个文件路径

public class Demo01PrintStream {
    public static void main(String[] args) throws FileNotFoundException {

        //创建打印流PrintStream对象,构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("10_IO\\print.txt");
        ps.write(97);//如果使用继承自父类的write方法写数据,你写的97，打开看就是a
        ps.println(97);//如果使用自己特有的方法print/println方法写数据,写的数据是97，看到的也是97
        ps.println(8.8);
        ps.println('a');
        ps.println("HelloWorld");
        ps.println(true);

        //释放资源
        ps.close();
    }
}

System.out.println();一般是打印在控制台的，但使用System.setOut方法可以改变打印的位置
static void setOut(PrintStream out)：参数的目的地在哪里就把文字打印在哪里

public class Demo02PrintStream {
    public static void main(String[] args) throws FileNotFoundException {

        PrintStream ps = new PrintStream("C:\\abc\\abc.txt");
        System.setOut(ps);
        System.out.println("我在打印流的目的地中输出");//控制台不再输出这句话，而是在"C:\\abc\\abc.txt"里面

        ps.close();
    }
}