07-28 缓冲流、转换流、序列化流

爱因斯蛋

于 2021-07-29 19:22:25 发布

阅读量79

点赞数

本文链接：https://blog.csdn.net/Coco2cy/article/details/119218725

版权

缓冲流

缓冲流,也叫⾼效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：

字节缓冲流： BufferedInputStream ， BufferedOutputStream

字符缓冲流： BufferedReader ， BufferedWriter

缓冲流的基本原理，是在创建流对象时，先将数据缓冲起来，然后⼀起写⼊或者读取出来，减少系统IO次数，从⽽提⾼读写的效率。

字节缓冲流

1.基本流

package com.chen.buffered;
/*
 *@description:基本流
 *@author:陈琰
 *@time：2021/7/28  18:36
 */

import java.io.*;

public class Demo01 {
    public static void main(String[] args)  throws FileNotFoundException {
        //基本流
        // 记录开始时间
        long start = System.currentTimeMillis();
        // 创建流对象
        try {
            FileInputStream fis = new
                    FileInputStream("C:\\Users\\ASUS\\Desktop\\test\\1.jpg");
            FileOutputStream fos = new
                    FileOutputStream("C:\\Users\\ASUS\\Desktop\\test\\2.jpg");
            // 读写数据
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");

        //---------------普通流复制时间:2190 毫秒
	}
}

2.缓冲流

package com.chen.buffered;
/*
 *@description:字节缓冲流
 *@author:陈琰
 *@time：2021/7/28  18:36
 */

import java.io.*;

public class Demo01 {
    public static void main(String[] args)  throws FileNotFoundException {
        //缓冲流
        // 记录开始时间
        long start = System.currentTimeMillis();
        // 创建流对象
        try (
                BufferedInputStream bis = new BufferedInputStream(new
                        FileInputStream("C:\\Users\\ASUS\\Desktop\\test\\1.jpg"));
                BufferedOutputStream bos = new BufferedOutputStream(new
                        FileOutputStream("C:\\Users\\ASUS\\Desktop\\test\\3.jpg"));
        ){
            // 读写数据
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");

        //缓冲流复制时间:13 毫秒
         }
}

3.缓冲流+数组输出

package com.chen.buffered;
/*
 *@description:字节缓冲流
 *@author:陈琰
 *@time：2021/7/28  18:36
 */

import java.io.*;

public class Demo01 {
    public static void main(String[] args)  throws FileNotFoundException {//缓冲流+数组
        // 记录开始时间
        long start = System.currentTimeMillis();
        // 创建流对象
        try (
                BufferedInputStream bis = new BufferedInputStream(new
                        FileInputStream("C:\\\\Users\\\\ASUS\\\\Desktop\\\\test\\\\1.jpg"));
                BufferedOutputStream bos = new BufferedOutputStream(new
                        FileOutputStream("C:\\\\Users\\\\ASUS\\\\Desktop\\\\test\\\\5.jpg"));
        ){
            // 读写数据
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");

        //缓冲流复制时间:3 毫秒

    }
}

字符缓冲流

构造⽅法

public BufferedReader(Reader in) ：创建⼀个新的缓冲输⼊流。
public BufferedWriter(Writer out) ：创建⼀个新的缓冲输出流。

// 创建字符缓冲输⼊流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本⽅法与普通字符流调⽤⽅式⼀致，不再阐述，我们来看它们具备的特有⽅法。

BufferedReader： public String readLine() : 读⼀⾏⽂字。
BufferedWriter:public void newLine() : 写⼀⾏⾏分隔符,由系统属性定义符号。

1.readLine()

package com.chen.buffered;
/*
 *@description:字符缓冲流
 *@author:陈琰
 *@time：2021/7/28  19:00
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {

        System.out.println("====readLine⽅法演示====");
        //创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        //定义字符串，保存读取的一行文字
        String line = null;
        //循环读取，读到最后返回null
        while ((line = br.readLine())!=null){
            System.out.println(line);
            System.out.println("------------");
        }
        br.close();
        /**
         * 湖南常德加油！！！
         * ------------
         * 打败疫情！！！
         * ------------
         */
    }
}

2.newLine ⽅法演示

// 创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
        // 写出数据
        bw.write("常德加油！");
        // 写出换⾏
        bw.newLine();
        bw.write("打败疫情！");
        bw.newLine();
        // 释放资源
        bw.close();
        /**
         * 常德加油！
         * 打败疫情！
         */

转换流

字符编码

编码: 字符(能看懂的)–>字节(看不懂的)

解码: 字节(看不懂的)–>字符(能看懂的)

字符集

字符集 Charset ：也叫编码表。是⼀个系统⽀持的所有字符的集合，包括各国家⽂字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进⾏字符编码，⼀套字符集必然⾄少有⼀套字符编码。常⻅字符

集有ASCII字符集、GBK字符集、Unicode字符集等。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B4o0JF5s-1627557734220)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20210728204919216.png)]

可⻅，当指定了编码，它所对应的字符集⾃然就指定了，所以编码才是我们最终要关⼼的。

ASCII字符集 ：
- ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字⺟的⼀套电脑编码系统，⽤于显示现代英语，主要包括控制字符（回⻋键、退格、换⾏键等）和可显示字符（英⽂⼤⼩写字符、阿拉伯数字和⻄⽂符号）。
- 基本的ASCII字符集，使⽤7位（bits）表示⼀个字符，共128字符。ASCII的扩展字符集使⽤8位（bits）表示⼀个字符，共256字符，⽅便⽀持欧洲常⽤字符。
ISO-8859-1字符集：
- 拉丁码表，别名Latin-1，⽤于显示欧洲使⽤的语⾔，包括荷兰、丹⻨、德语、意⼤利语、⻄班⽛语等。
- ISO-8859-1使⽤单字节编码，兼容ASCII编码。
GBxxx****字符集：
- GB就是国标的意思，是为了显示中⽂⽽设计的⼀套字符集。
- GB2312：简体中⽂码表。⼀个⼩于127的字符的意义与原来相同。但两个⼤于127的字符连在⼀起时，就表示⼀个汉字，这样⼤约可以组合了包含7000多个简体汉字，此外数学符号、罗⻢希腊的字⺟、⽇⽂的假名们都编进去了，连在ASCII⾥本来就有的数字、标点、字⺟都统统重新编了两个字节⻓的编码，这就是常说的"全⻆"字符，⽽原来在127号以下的那些就叫"半⻆"字符了。
- GBK：最常⽤的中⽂码表。是在GB2312标准基础上的扩展规范，使⽤了双字节编码⽅案，共收录了21003个汉字，完全兼容GB2312标准，同时⽀持繁体汉字以及⽇韩汉字等。
- GB18030：最新的中⽂码表。收录汉字70244个，采⽤多字节编码，每个字可以由1个、2个或4个字节组成。⽀持中国国内少数⺠族的⽂字，同时⽀持繁体汉字以及⽇韩汉字等。
- Unicode****字符集 ：Unicode编码系统为表达任意语⾔的任意字符⽽设计，是业界的⼀种标准，也称为统⼀码、标准万国码。
- 它最多使⽤4个字节的数字来表达每个字⺟、符号，或者⽂字。有三种编码⽅案，UTF-8、UTF-16和UTF-32。最为常⽤的UTF-8编码。UTF-8编码，可以⽤来表示Unicode标准中任何字符，它是电⼦邮件、⽹⻚及其他存储或传送⽂字的应⽤中，优先采⽤的编码。互联⽹⼯程⼯作⼩组（IETF）要求所有互联⽹协议都必须⽀持UTF-8编码。所以，我们开发Web应⽤，也要使⽤UTF-8编码。它使⽤⼀⾄四个字节为每个字符编码，编码规则：

128个US-ASCII字符，只需⼀个字节编码。
拉丁⽂等字符，需要⼆个字节编码。
⼤部分常⽤字（含中⽂），使⽤三个字节编码。
其他极少使⽤的Unicode辅助字符，使⽤四字节编码。

InputStreamReader类

// 定义⽂件路径,⽂件为gbk编码
        String FileName = "in.txt";
        // 创建流对象,默认UTF8编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
        // 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) ,
                "GBK");
        // 定义变量,保存字符
        int read;
        // 使⽤默认编码字符流读取,正常解析
        while ((read = isr.read()) != -1) {
            System.out.print((char)read);

        }
        isr.close();
System.out.println("================");
        // 使⽤指定编码字符流读取,乱码
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);
        }
        isr2.close();


/**
*湖南常德加油！！！
*打败疫情！！！================
*婀栧崡甯稿痉鍔犳补锛侊紒锛�
*鎵撹触鐤儏锛侊紒锛�
*/

OutputStreamWriter类

//定义文件路径
        String FileName = "out.txt";
        //创建流对象,,默认UTF-8编码

        OutputStreamWriter osw = new OutputStreamWriter(new
FileOutputStream(FileName));
        //写出数据
        osw.write("你好");//你好
        osw.close();

        //定义文件路径
        String FileName2 = "out2.txt";
        //创建流对象,,默认UTF-8编码

        OutputStreamWriter osw2 = new OutputStreamWriter(new
                FileOutputStream(FileName2),"GBK");
        //写出数据
        osw2.write("你好");//���
        osw2.close();

序列化

student类

package com.chen.serialization;
/*
 *@description:描述
 *@author:陈琰
 *@time：2021/7/28  21:18
 */

public class Student implements java.io.Serializable{
    public String name;
    public String address;
    public transient int age;
    public void addressCheck(){
        System.out.println("Address  check : "+name+" -- "+address);
    }
}

序列化类

package com.chen.serialization;
/*
 *@description:序列化
 *
 *@author:陈琰
 *@time：2021/7/28  21:11
 */

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

//序列化  把对象储存在文件中
public class Demo01 {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "zhangsan";
        stu.address = "nt";
        stu.age = 23;

        try {
            //创建序列化对象
            ObjectOutputStream out = new ObjectOutputStream(new
    FileOutputStream("student.txt"));
            //写出对象
            out.writeObject(stu);
            //释放资源
            out.close();
            System.out.println("Serialized data is saved");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

�� sr com.chen.serialization.StudentՇ�ʎ�� L addresst Ljava/lang/String;L nameq ~ xpt ntt zhangsan

反序列化！！！

package com.chen.serialization;
/*
 *@description:反序列化
 *@author:陈琰
 *@time：2021/7/28  21:41
 */

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

public class Demo02 {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "zhangsan";
        stu.address = "nt";
        stu.age = 23;
        try {
            // 创建反序列化流
            FileInputStream fileIn = new FileInputStream("Student.txt");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // 读取⼀个对象
            stu = (Student) in.readObject();
            // 释放资源
            in.close();
            fileIn.close();
        }catch(IOException i) {
            // 捕获其他异常
            i.printStackTrace();
            return;
        }catch(ClassNotFoundException c) {
            // 捕获类找不到异常
            System.out.println("Employee class not found");
            c.printStackTrace();
            return;
        }
        // ⽆异常,直接打印输出
        System.out.println("Name: " + stu.name); // zhangsan
        System.out.println("Address: " + stu.address); // beiqinglu
        System.out.println("age: " + stu.age); // 0
    }
}


/**
*Name: zhangsan
*Address: nt
*age: 0
*/

       return;
    }catch(ClassNotFoundException c) {
        // 捕获类找不到异常
        System.out.println("Employee class not found");
        c.printStackTrace();
        return;
    }
    // ⽆异常,直接打印输出
    System.out.println("Name: " + stu.name); // zhangsan
    System.out.println("Address: " + stu.address); // beiqinglu
    System.out.println("age: " + stu.age); // 0
}

}

/**
*Name: zhangsan
*Address: nt
*age: 0
*/

爱因斯蛋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
07-28 缓冲流、转换流、序列化流

缓冲流缓冲流,也叫⾼效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：字节缓冲流： BufferedInputStream ， BufferedOutputStream 字符缓冲流： BufferedReader ， BufferedWriter缓冲流的基本原理，是在创建流对象时，先将数据缓冲起来，然后⼀起写⼊或者读取出来，减少系统IO次数，从⽽提⾼读写的效率。字节缓冲流1.基本流package com.chen.buffered;/*
复制链接

扫一扫