JAVA IO流

严文文-Chris

已于 2022-03-21 11:38:18 修改

阅读量349

点赞数

分类专栏： JAVA 文章标签： java

于 2022-03-21 11:37:05 首次发布

本文链接：https://blog.csdn.net/yanwenwennihao/article/details/123569778

版权

JAVA 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

JAVA IO流

背景

背景

本人在实践COS分块上传是发现需要使用到IO流，但是对流如何分段获取有疑惑，所以系统学习下IO流。

为什么需要IO流

当我们程序需要从硬盘，网络，或其他程序读取或者写入数据时，数据传输量可能很大，但是我们的内存和带宽有限，无法一次新读取或者写入大量数据
流可以帮助我们实现分批逐步传输数据
下载一个大文件是可以在内存中划分一个缓冲区，一点一点下载到自己的内存，等缓存区满了再写到硬盘

什么是流 stream

流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类

可以从三个不同的维度进行分类：

1、按照流的方向（输出输入都是站在程序所在内存的角度划分的）
• 输入流：只能从中读取数据【主要由InputStream和Reader作为基类】

• 输出流：只能向其写入数据【主要由outputStream和Writer作为基类】

在下图中，从磁盘读取数据到内存是输入流，从client读取数据到server是输入流；同样，把内存数据写到磁盘是输出流，把server数据写到client是输出流
在这里插入图片描述

2、按照流的操作颗粒度划分

• 字节流：以字节为单元，可操作任何数据【主要由InputStream和outPutStream作为基类】

• 字符流：以字符为单元，只能操作纯字符数据，比较方便【主要由Reader和Writer作为基类】

3、按照流的角色划分

• 节点流：可以从/向一个特定的IO设备（如磁盘，网络）读/写数据的流，也叫【低级流，主要由】

• 处理流：用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能，也叫【高级流】

下图中可以看出来，处理流就是在基础的字节流上，进行了封装，增加了特定的功能，使得传输更适合特定的场景。
在这里插入图片描述

类图结构

在这里插入图片描述

常见的处理流

Buffering缓冲流：在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。
Filtering 滤流：在数据进行读或写时进行过滤：FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。
Converting between Bytes and Characters 转换流：按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader）：InputStreamReader、OutputStreamWriter。
Object Serialization 对象流：ObjectInputStream、ObjectOutputStream。
DataConversion数据流：按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream 。
Counting计数流：在读入数据时对行记数：LineNumberReader、LineNumberInputStream。
Peeking Ahead预读流：通过缓存机制，进行预读：PushbackReader、PushbackInputStream。
8 .Printing打印流：包含方便的打印方法：PrintWriter、PrintStream。

FileInputStream & FileOutputStream

FileInputStream & FileOutputStream 可以从文件系统中读取/写入诸如图像数据之类的原始字节流。
以下是使用 FileInputStream & FileOutputStream 实现文件拷贝的案例

// 使用文件字节流 一次拷贝一个字节
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //2. 读写数据
        int data = in.read();
        while (data != -1) {
            os.write(data);
            data = in.read();
        }

        //3. 关闭流
        in.close();
        os.close();
    }

    // 使用文件字节流 一次拷贝一个字节数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //2. 读写数据
        byte[] buffer = new byte[2048];
        int len = in.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = in.read(buffer);
        }
        //3. 关闭流
        in.close();
        os.close();
   }

DataInputStream & DataOutputStream

DataInputStream & DataOutputStream，是处理流，改构造方法接收一个已存在的输入输出流，允许程序从读取方便快捷操作java的基本数据类型。

// 向文件中写入 java基本数据类型
    private static void write(String dest) throws IOException {
        //1. 创建流对象
        DataOutputStream os = new DataOutputStream(new FileOutputStream(dest));
        //2. 写入数据
        os.writeInt(10);
        os.writeChar('a');
        os.writeChar('b');
        os.writeDouble(12.83);
        //3. 关闭流
        os.close();
}

    // 从文件中读取 java基本数据类型，要和写入的顺序保持一致
    private static void read(String src) throws IOException {
        //1. 创建数据流对象
        DataInputStream in = new DataInputStream(new FileInputStream(src));
        //2. 读取数据
        int a = in.readInt();
        char b = in.readChar();
        char c = in.readChar();
        double d = in.readDouble();
        //3. 关闭流
        in.close();
    }

BufferedInputStream & BufferedOutputStream

BufferedInputStream & BufferedOutputStream 为另一个输入输出流流添加一些功能，即缓冲区的作用。在创建 BufferedInputStream & BufferedOutputStream 时，会创建一个内部缓冲区数组。

// 为文件字节流 添加缓冲区功能， 一次读写一个字节数据，但内部缓冲区数组已经填满
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

        //2. 读写数据
        int data = in.read();
        while (data != -1) {
            os.write(data);
            data = in.read();
        }

        //3. 关闭流
        in.close();
        os.close();
    }

    // 为文件字节流 添加缓冲区功能， 一次读写一个字节数组数据，但内部缓冲区数组已经填满
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

        //2. 读写数据
        byte[] buffer = new byte[2048];
        int len = in.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = in.read(buffer);
        }
        //3. 关闭流
        in.close();
        os.close();
    }

PrintStream

PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

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

        PrintStream ps = new PrintStream("test.txt");
        ps.println(5);
        ps.print("Aaaa");
        ps.print(false);
        ps.println("hahah");

        ps.flush();
        ps.close();
    }

ByteArrayInputStream & ByteArrayInputStream

ByteArrayInputStream & ByteArrayInputStream 包含一个内部缓冲区(实际上就是把数据写入内存，然后再读取)，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节,.

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

        //1. 写入数据
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        os.write("hello".getBytes());
        os.close(); // 没有写任何实现

        //2. 读取输出
        byte[] bytes = os.toByteArray();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);

        byte[] data = new byte[1014];
        int len = in.read(data);
        System.out.println(new String(data, 0 ,len));

    }

InputStreamReader & OutputStreamWriter

java 在jdk1.1种提供了，针对字符处理的方便类,字符流，将原来的字节流，增加了字符编码表编码处理功能
字节流到字符流的转换流，read（）和writer（）方法会一次输入输出多个字节，以包装字符转换有效，
字节流 + 编码表 = InputStreamReader & OutputStreamWriter

// 使用 字符转换流， 实现文本文件的 拷贝
    // 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new InputStreamReader(new FileInputStream(src));
        Writer writer = new OutputStreamWriter(new FileOutputStream(dest));

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new InputStreamReader(new FileInputStream(src));
        Writer writer = new OutputStreamWriter(new FileOutputStream(dest));

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

FileReader & FileWriter

在只针对将字符写入文件的时候，因为每次使用转换流，对字节流进行包装，写法太麻烦，所以jdk 提供了字节转换流子类FileReader & FileWriter，方便的进行字符文件的IO操作

// 使用 字符转换流， 实现文本文件的 拷贝
    // 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new FileReader(src);
        Writer writer = new FileWriter(dest);

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new FileReader(src);
        Writer writer = new FileWriter(dest);

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

BufferedReader & BufferedWriter

// 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new BufferedReader(new FileReader(src));
        Writer writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new BufferedReader(new FileReader(src));
        Writer writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个一整行的 字符串
    private static void copyFile3(String src, String dest) throws IOException {
        //1. 创建转换流
        BufferedReader reader = new BufferedReader(new FileReader(src));
        BufferedWriter writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        String data = reader.readLine();
        while (data != null) {
            writer.write(data);
            writer.newLine();
            data = reader.readLine();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

StringReader & StringWriter

方便快捷的将字符串写入内存，或从内存读取

public static void main(String[] args) throws IOException, NoSuchFieldException {
        //1. 向内存写入数据，其内部提供了一个缓冲区
        StringWriter writer = new StringWriter();
        writer.write("hello world");

        //2. 读取数据
        StringReader reader = new StringReader(writer.toString());

        char[] data = new char[1024];
        int len =  reader.read(data);

        System.out.println(new String(data,0,len));
    }

为什么字符流需要 flush，而字节流不需要

字节流不需要 flush 操作是因为字节流直接操作的是字节，中途不需要做任何转换，所以直接就可以操作文件，而字符流，说到底，其底层还是字节流，但是字符流帮我们将字节转换成了字符，这个转换需要依赖字符表，所以就需要在字符和字节完成转换之后通过 flush 操作刷到磁盘中。

需要注意的是，字节输出流最顶层类 OutputStream 中也提供了 flush 方法，但是它是一个空的方法，如果有子类有需要，也可以实现 flush 方法。

严文文-Chris

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA IO流

JAVA IO流背景为什么需要IO流什么是流 streamIO流的分类类图结构为什么字符流需要 flush，而字节流不需要背景本人在实践COS分块上传是发现需要使用到IO流，但是对流如何分段获取有疑惑，所以系统学习下IO流。为什么需要IO流当我们程序需要从硬盘，网络，或其他程序读取或者写入数据时，数据传输量可能很大，但是我们的内存和带宽有限，无法一次新读取或者写入大量数据流可以帮助我们实现分批逐步传输数据下载一个大文件是可以在内存中划分一个缓冲区，一点一点下载到自己的内存，等缓存区满了再写到
复制链接

扫一扫

专栏目录