Java中的四大流:[缓冲流][转换流][对象流][打印流]

最新推荐文章于 2024-06-23 09:17:53 发布

阿胡爱编程

最新推荐文章于 2024-06-23 09:17:53 发布

阅读量144

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_72926194/article/details/134305517

版权

文章目录

缓冲流
转换流
对象流
打印流

本文章主要介绍一下java中三大流的基本概念以及基础用法

缓冲流

1.概述

    缓冲流,也叫高效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：
    1.字节缓冲流： BufferedInputStream ， BufferedOutputStream
    2.字符缓冲流： BufferedReader ， BufferedWriter
缓冲流的基本原理:
    在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

2.效率测试

字节缓冲流

通过代码探究缓冲流为什么被称作高效流.
基本流:

package BoKe.javaadvance;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

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

在这里插入图片描述

缓冲流:

package BoKe.javaadvance;

import java.io.*;

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

在这里插入图片描述
从上面的测试我们可以看出使用缓冲流能够让我们高效的读取文件和写入文件.

当然,也可以通过数组的方式让我们读取文件的速度更快

package BoKe.javaadvance;

import java.io.*;

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
        long start = System.currentTimeMillis();
// 创建流对象
        try (
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ) {
// 读写数据
            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) + " 毫秒");
    }
}

字符缓冲流

注意点:
字符缓冲流拥有其特殊的方法readLine(),newLine()
代码演示:
readLine()方法

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        // 定义字符串,保存读取的一行文字
        String line = null;
        // 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("‐‐‐‐‐‐");
        }
        // 释放资源
        br.close();
    }
}

newLine()方法

public class BufferedWriterDemo throws IOException {
    public static void main(String[] args) throws IOException  {
        // 创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
        // 写出数据
        bw.write("天地会");
        // 写出换行
        bw.newLine();
        bw.write("程进");
        bw.newLine();
        bw.write("南");
        bw.newLine();
        // 释放资源
        bw.close();
    }
}

转换流

前言:字符编码和字符集

字符编码和字符集

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本f符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

字符集

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

InputStreamReader类

转换流 java.io.InputStreamReader ，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

指定编码读取

package BoKe.javaadvance;

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

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
        // 定义文件路径,文件为gbk编码
        String FileName = "C:\\test1\\a.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类

转换流 java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

指定编码写出

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个字节
        osw.close();
        // 定义文件路径
        String FileName2 = "E:\\out2.txt";
        // 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 写出数据
        osw2.write("你好");// 保存为4个字节
        osw2.close();
    }
}

转换流理解图:
在这里插入图片描述

对象流

对象流的主要作用是进行序列化
在这里插入图片描述

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

序列化操作

条件:
1.该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
2.该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
示例:
1.创建一个Employee类,并且使其继承Serializable 接口.

package BoKe.javaadvance;

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化

    public void addressCheck() {
        System.out.println("Address check : " + name + " ‐‐ " + address);
    }
}

2.创建一个测试类进行测试.

package BoKe.javaadvance;

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

public class SerializeDemo {
    public static void main(String[] args) {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20;
        try {
            // 创建序列化流对象
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("C:\\test1\\employee.txt"));
            // 写出对象
            out.writeObject(e);
            // 释放资源
            out.close();

            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch (IOException i) {
            i.printStackTrace();
        }
    }
}

在这里插入图片描述
通过上面的运行结果,我们可以看到我们的对象已经被存入到了内存中,进行了序列化.

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
这里我们将刚才已经序列化的对象,读取出来

package BoKe.javaadvance;

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

public class DeserializeDemo {
    public static void main(String[] args) {
        Employee e = null;
        try {
            // 创建反序列化流
            FileInputStream fileIn = new FileInputStream("C:\\test1\\employee.txt");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // 读取一个对象
            e = (Employee) 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: " + e.name); // zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

在这里插入图片描述

打印流

平时我们在控制台打印输出，是调用 print 方法和 println 方法完成的，这两个方法都来自于java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。
代码示例:

public class PrintDemo {
	public static void main(String[] args) throws IOException {
	// 调用系统的打印流,控制台直接输出97
	System.out.println(97);
	// 创建打印流,指定文件的名称
	PrintStream ps = new PrintStream("C:\\test1\\employee.txt");
	// 设置系统的打印流流向,输出到ps.txt
	System.setOut(ps);
	// 调用系统的打印流,ps.txt中输出97
	System.out.println(97);
}
}

以上就是java中四大流对象的基本使用方法了,当然java中肯定不止这些流,感兴趣的小伙伴可以深入了解~

阿胡爱编程

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java中的四大流:[缓冲流][转换流][对象流][打印流]

缓冲流,也叫高效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：1.字节缓冲流： BufferedInputStream ， BufferedOutputStream2.字符缓冲流： BufferedReader ， BufferedWriter缓冲流的基本原理在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
复制链接

扫一扫