【Java IO流】缓冲流和对象流的解析和应用实例

已于 2024-03-17 22:30:14 修改
阅读量1.2k 收藏 33
点赞数 28
分类专栏： Java 文章标签： java 笔记 IO流
于 2024-03-17 22:29:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjsjzhx/article/details/136790125
版权

目录

前言

一、缓冲流

四种方式拷贝文件的用时对比

二、对象流

1. 使用对象流写入对象到本地文件

2. 使用对象流读取对象数据

总结

前言

【File文件管理及IO流（基本流）】icon-default.png?t=N7T8http://t.csdnimg.cn/uG5Ff 该篇博客中，介绍了学习高级流需要的前置知识：

  1. 文件管理

  2. 基本的输入输出流：了解基本的输入输出流的概念和使用方法，包括字节流和字符流，以及如何读写文件或处理其他数据源。

Java 中的高级流指的是建立在基本字节流或字符流之上的流，它们提供了更高级别的功能以简化 I/O 操作。除缓冲流和对象流外，常见的高级流还有：数据流、打印流、压缩流、转换流等。

一、缓冲流

缓冲流（Buffered Streams）在 Java 中是一种用于提高输入输出效率的流。它们通过在内存中创建缓冲区来减少对底层资源（如文件、网络连接）的频繁访问，从而提高读写数据的性能。

常见的缓冲流包括：

  • BufferedInputStream（字节缓冲输入流）
  • BufferedOutputStream（字节缓冲输出流）
  • BufferedReader（字符缓冲输入流）
  • BufferedWriter（字符缓冲输出流）

它们构造方法的参数都是对应的基本流，例如：

public BufferedInputStream(InputStream is)

缓冲流的原理：底层自带了长度为8192的缓冲区提高性能。

缓冲中的两个独有方法（非常实用）：

1.readLine() 读取一行
用于从输入流中读取一行文本数据，并返回一个字符串表示该行数据。这个方法通常用于读取文本文件中的内容，逐行读取文本信息。

             
2.newLine() 通用换行
作用是写入一个平台无关的行分隔符，即换行符。
使用 newLine()方法可以根据当前平台自动生成正确的换行符，而不需要手动编写特定的换行符。
通常情况下，不同操作系统的行分隔符如下：
      （1）Windows 系统使用回车符和换行符表示行尾，即\r\n
      （2）Unix 和类 Unix 系统（如 Linux）使用换行符表示行尾，即 \n。
      （3）旧版 Mac OS 使用回车符表示行尾，即 \r。 

为方便读取文本文件，这里用字符缓冲流进行示例(需要创建好对应的文件，路径也要正确)：

import java.io.*;

public class CharacterBS {  //字符缓冲流
    public static void main(String[] args) throws IOException {
        //读取数据(输入流)
        BufferedReader br = new BufferedReader(new FileReader("File\\buffer.txt"));

        //两个独有方法：readLine() 读取一行
        //            newLine() 通用换行
        String s;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        br.close();

        //写数据(输出流)
        BufferedWriter bw = new BufferedWriter(new FileWriter("File\\buffer2.txt"));
        bw.write("缓冲流（Buffered Streams）");
        bw.newLine();
        bw.write("BufferedReader：提供缓冲读取文本数据的功能。");
        bw.newLine();
        bw.write("BufferedWriter：提供缓冲写入文本数据的功能。");
        bw.newLine();
        bw.close();
    }
}

读取的数据：

写入的数据： 

四种方式拷贝文件的用时对比

拷贝文件
    四种方式拷贝文件(边读边写)，并统计各自用时(这里的文件越大越好，太小体现不出差别)

    1.字节流的基本流：一次读写一个字节
    2.字节流的基本流：一次读写一个字节数组[8192]
    3.字节缓冲流：一次读写一个字节
    4.字节缓冲流：一次读写一个字节数组[8192]

import java.io.*;

public class Test1 {
    public static void main(String[] args) throws IOException {
        /*
        拷贝文件
            四种方式拷贝文件，并统计各自用时

            字节流的基本流：一次读写一个字节
            字节流的基本流：一次读写一个字节数组
            字节缓冲流：一次读写一个字节
            字节缓冲流：一次读写一个字节数组
         */
        long time1 = method1();
        long time2 = method2();
        long time3 = method3();
        long time4 = method4();
        System.out.println(time1);
        System.out.println(time2);
        System.out.println(time3);
        System.out.println(time4);
    }

    private static long method1() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("File\\read.txt");
        FileOutputStream fos = new FileOutputStream("File\\write.txt");
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
        fos.close();
        fis.close();
        long end = System.currentTimeMillis();
        return end - start;
    }

    private static long method2() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("File\\read.txt");
        FileOutputStream fos = new FileOutputStream("File\\write.txt");
        byte[] bytes = new byte[8192];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        fos.close();
        fis.close();
        long end = System.currentTimeMillis();
        return end - start;
    }

    private static long method3() throws IOException {
        long start = System.currentTimeMillis();
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("File\\read.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("File\\write.txt"));
        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }
        bos.close();
        bis.close();
        long end = System.currentTimeMillis();
        return end - start;
    }

    private static long method4() throws IOException {
        long start = System.currentTimeMillis();
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("File\\read.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("File\\write.txt"));
        byte[] bytes = new byte[8192];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.close();
        bis.close();
        long end = System.currentTimeMillis();
        return end - start;
    }
}

对比结果（文件太小了所以读写字节数组的差距没有体现）： 

  1. 字节流的基本流：一次读写一个字节
  2. 字节流的基本流：一次读写一个字节数组[8192]
  3. 字节缓冲流：一次读写一个字节
  4. 字节缓冲流：一次读写一个字节数组[8192]

二、对象流

对象流（Object Streams）也叫序列化/反序列化流，是 Java 中用于读写对象的流。对象流可以将对象以二进制形式序列化（Serialization）后写入输出流，也可以从输入流中读取二进制数据并反序列化（Deserialization）为对象。

Java 提供了两个主要的对象流类：

  1. ObjectOutputStream：用于将对象序列化后写入输出流。
  2. ObjectInputStream：用于从输入流中读取二进制数据并反序列化为对象。

同缓冲流，它们构造方法的参数也是基本流：

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("objects.bin"));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("objects.bin"));

需要注意的是，要使对象能够被序列化，该对象所属的类必须实现 Serializable 接口。序列化过程会将对象转换成字节序列，因此对象的字段和类的结构都需要支持序列化。

对象流的使用场景包括但不限于：保存和加载对象数据（因为写入到文件后是一对看不懂的数据）、对象的网络传输等。

作用：通过对象流，我们可以方便地将对象以二进制形式写入到输出流中，并从输入流中读取并还原为对象，实现了对象的持久化和简化了数据传输。写入到文件后

细节：
    要写出的对象必须实现Serializable接口(标记性接口) + serialVersionUID(版本号)
    否则会抛出NotSerializableException异常

写入对象的方法：writeObject(对象);

读取对象的方法：readObject(); 返回值：Object

1. 使用对象流写入对象到本地文件

写入对象前的准备工作，自定义类：

import java.io.Serial;
import java.io.Serializable;

public class Student implements Serializable {
    @Serial
    private static final long serialVersionUID = -3931917465211028662L;
    private String name;
    private int age;
    //transient: 瞬态关键字
    //作用：不会把当前属性序列化到本地文件当中
    private transient String address;


    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     *
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     *
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", address = " + address + "}";
    }
}
import java.io.Serial;
import java.io.Serializable;

public class Teacher implements Serializable {
    @Serial
    private static final long serialVersionUID = 2983184546427358899L;
    private String name;
    private int age;
    private String address;

    public Teacher() {
    }

    public Teacher(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     *
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     *
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Teacher{name = " + name + ", age = " + age + ", address = " + address + "}";
    }
}

写入一个对象： 

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

public class Test1 {    //序列化流/对象操作输出流
    public static void main(String[] args) throws IOException {
        /*
        需求：
            利用序列化流/对象操作输出流，把一个对象写到本地文件中

            细节：
                要写出的对象必须实现Serializable接口(标记性接口) + serialVersionUID(版本号)
                否则回抛出NotSerializableException异常

            transient: 瞬态关键字
            作用：不会把当前属性序列化到本地文件当中
         */

        //1.创建对象
        Student stu = new Student("张三", 23, "厦门");

        //2.创建续流化流/对象操作输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("File\\object.txt"));

        //3.写出对象
        oos.writeObject(stu);

        //4.关流
        oos.close();
    }
}

写入后的数据： 

写入多个对象：

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

public class Test_1 {
    public static void main(String[] args) throws IOException {
        /*
        用对象流读写多个对象
            需求：
                将多个自定义对象序列化到文件中，但是由于对象的个数不确定，反序列流该如何读取？
         */

        //序列化多个对象
        //1.创建对象
        Teacher t1 = new Teacher("张三", 23, "北京");
        Teacher t2 = new Teacher("李四", 24, "上海");
        Teacher t3 = new Teacher("王五", 25, "深圳");

        //2.将对象添加到集合中
        ArrayList<Teacher> list = new ArrayList<>();
        list.add(t1);
        list.add(t2);
        list.add(t3);

        //3.序列化集合
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("File\\teacher.txt"));
        oos.writeObject(list);

        //4.关流
        oos.close();
    }
}

2. 使用对象流读取对象数据

读取单个对象：

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

public class Test2 {    //反序列化流/对象操作输入流
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建反序列化流/对象操作输入流
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("File\\object.txt"));

        //2.读取数据
        Object o = ois.readObject();

        //3.打印对象
        System.out.println(o);

        //4.释放资源
        ois.close();
    }
}

运行结果：

读取多个对象：

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

public class Test_2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("File\\teacher.txt"));

        //2.读取数据
        ArrayList<Teacher> o = (ArrayList<Teacher>) ois.readObject();
        //System.out.println(o);
        for (Teacher teacher : o) {
            System.out.println(teacher);
        }

        //3.关流
        ois.close();
    }
}

运行结果： 

总结

当涉及到 Java I/O 操作时，缓冲流和对象流是两种非常常用的高级流。

缓冲流的功能：

  1. 提供了缓冲区功能，可以减少对底层数据源的直接访问次数，从而提高读写效率。
  2. 适用于对大量数据进行读写操作。

缓冲流的优点：

  1. 提高了I/O操作的性能，减少了与底层数据源的交互次数。
  2. 提供了逐行读取文本数据的功能，方便文本处理操作。

对象流的功能：

  1. 用于将对象序列化成字节流或反序列化为对象。
  2. 可以实现对象的持久化、网络传输和跨平台数据交换等功能。

对象流的优点：

  1. 方便实现对象的保存和加载，简化了对象的序列化和反序列化过程。
  2. 可以实现对象在不同系统之间的传输和共享。

综上所述，缓冲流适用于提高读写效率和处理大量数据，而对象流则适用于处理对象的序列化和反序列化，方便实现对象数据的持久化和传输。根据具体需求，可以选择合适的流来进行数据操作。

new Random()
关注
专栏目录
java缓冲流使用
java编程学习_java基础教程_booyzhang的博客
05-09 257
缓冲流： 解决了对文件或其他目标频繁的读写操作，效率低，性能差的问题。 使用缓冲流的好处是能够更高效的读写信息，原理是将数据线缓冲起来，然后一起写入或者读取出来。 BufferedInputSream： 为另一个输入流添加一些功能，在创建BufferedInputSream时，会创建一个内部缓冲区数组，用于缓冲数据 BufferedOutputStream： 通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统 BufferedReader： 从字符输入流中读取文
Java IO流之字符缓冲流实例详解
08-26
Java IO流中的字符缓冲流（Character Buffer Stream）是提高数据读写效率的重要工具，它针对字符流进行优化，尤其在处理大量文本数据时效果显著。本文将深入解析字符缓冲流的使用及其作用。 字符流主要分为两个核心...
java 缓冲流
zzx03918的博客
12-13 490
通过本文的介绍，我们深入了解了Java缓冲流的原理、使用方法和注意事项。缓冲流通过在内存中创建缓冲区，减少了直接与底层I/O设备的交互次数，从而提高了数据读写效率。在实际应用中，我们可以通过创建BufferedInputStream或BufferedOutputStream对象来使用缓冲流，并通过read()或write()方法进行数据的读取或写入。在使用缓冲流时，需要注意内存消耗情况、异常处理、资源关闭以及数据的完整性和正确性等问题。同时，在使用缓冲流进行网络传输时，需要注意网络连接的稳定性。
JAVA中的对象流ObjectInputStream
最新发布
qa3629723的博客
08-17 1136
需要注意的是，序列化机制并非适用于所有场景，例如敏感数据等，因此在设计类时，要充分考虑序列化的需求和潜在风险。ObjectInputStream是Java中用于序列化对象的一种输入流，它允许我们将对象的状态信息从输入流中读取出来，以便在后续程序中使用。可序列化类的 serialVersionUID 在可序列化类中，建议显式声明一个名为serialVersionUID的静态常量，用于标识该类的版本。反序列化则是将序列化后的数据恢复为对象的过程。定义一个可序列化的类 首先，我们需要定义一个可序列化的类。
Java中缓冲流的使用
weixin_46245201的博客
11-16 543
文章目录Java中缓冲流的使用（字节型）一、功能二、示例 Java中缓冲流的使用（字节型） 一、功能 内部提供了一个缓冲区，可以提高读写速度。 二、示例 @Test public void bufferedInputStreamTest() { FileInputStream fileInputStream = null; FileOutputStream fileOutputStream = null; BufferedInputStream buf
Java字节缓冲流的使用
m0_61788902的博客
08-01 124
Java字节缓冲流的使用
Java之缓冲流
m0_58398160的博客
09-01 211
1.缓冲流： 字节流于字符流：属于IO流的入门，那么即将学习的是更强大的流 缓冲流：高效流，是在基本流对象的基础上创建而来的，就像普通人穿上铠甲一样，相当于对基础流的一种增强 就是对四个基本的FileXXX流的增强，所以缓冲流也分为四个流 按照类型来区分： 字节缓冲流：BufferedInputStream、BufferedOutputStream 字符缓冲流：BufferedReader、Buffer...
Java IO字符流缓冲区实现原理解析
08-19
Java IO字符流缓冲区实现原理解析是Java编程语言中的一种重要机制，该机制旨在提高IO操作的效率和性能。缓冲区是Java IO字符流中的一种机制，它可以将数据暂存起来，以便提高读写效率。在本文中，我们将深入探讨Java...
Java-IO流/Stream流总结
07-12
Java的IO流与Stream流是Java程序中处理输入输出的核心技术。IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、...
马士兵老师的java io流课程
06-04
马士兵老师的课程通过生动的实例和深入的解析，使学员能够掌握这些概念，并能实际应用到项目开发中。通过学习，不仅可以提升对Java IO流的理解，还能增强解决实际问题的能力。对于准备面试或提高编程技能的开发者来...
Java IO流操作深度解析与实例汇总
本文档主要介绍了Java IO流的各种组合使用方法，这些方法在处理数据输入和输出时具有重要作用。以下是对文档中的四个关键示例的详细解读： 1. **缓冲输入文件**: 在`DataInputStream in`的创建过程中，通过嵌套...
java缓冲流
酷酷的锐的博客
09-01 453
BufferedOutputStream:字节缓冲输出流           缓冲输出流的特点是：在流里维护了一个缓冲区，写字节时，先将字节写入缓冲区，当缓冲区满时，再一次性的将数据写到文件里。这样就降低了写的次数，因此提高了效率。                     因为缓冲输出流缺失即时性，可以使用flush方法进行冲刷  PS:当一次写的字节超出缓冲区大小，会直接写入到文件中    ...
JAVA中的缓冲流
weixin_44131997的博客
12-16 516
JAVA中的字节字符缓冲流
Java-缓冲流
m0_47209867的博客
02-10 276
Java-缓冲流一、缓冲流概述二、字节缓冲输出流BufferedOutputStream三、字节缓冲输入流BufferedInputStream四、字符缓冲输出流BufferedWriter五、字符缓冲输入流BufferedReader 一、缓冲流概述 缓冲流：增强基本流的功能，在基本流的基础上演变而来。 按照数据类型进行分类分为： 字节缓冲流：BufferedInputStrem  BufferedOutputStream 字符缓冲流：BufferedReader  BufferedWriter 缓冲流的
Java：对象流：ObjectOutputStream、ObjectInputStream
m0_51755061的博客
04-15 710
对象流：ObjectOutputStream、ObjectInputStream1. 序列化：用ObjectOutputStream类从内存写入硬盘1.1 序列化机制：1.2 自定义类实现序列化需要满足的条件2. 反序列化：用ObjectInputStream类从硬盘读取到内存 对象流：强大之处：把内存中的对象存到硬盘中 1. 序列化：用ObjectOutputStream类从内存写入硬盘 1.1 序列化机制： 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地
Java 缓冲流
m0_47320958的博客
01-13 517
缓冲流概述 缓冲流也称为高效流、或者高级流。字节流可以称为原始流。 作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能 缓冲流 字节缓冲流 字节缓冲输入流:Bufferedlnputstream 字节缓冲输出流:BufferedOutputStream 字符缓冲流 字符缓冲输入流:BufferedReader 字符缓冲输出流:BufferedWriter 字节缓冲流性能优化原理: 字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。
java中缓冲流的使用
wopoli的博客
06-22 1114
功能：带缓冲区的将字节数据从内存写入硬盘文件的类 使用步骤： 1、创建一个字节输出流对象(例如：FileOutputStream类)，构造方法中传递存储数据的文件或者文件路径。 2、创建一个缓冲字节输出流对象，构造方法中传递字节输出流对象。 3、调用缓冲字节输出流的write方法写入数据。 4、调用缓冲字节输出流的close方法释放资源。功能：创建一个缓冲字节输出流对象。 用法：BufferedOutputStream 对象名 = new BufferedOutputStream(字节输出流对象) 示例：B
java 缓存使用_Java高级——缓存的使用场景
weixin_28856341的博客
02-15 265
当你的应用扛不住，知道要使用缓存了，应该怎么做呢？场景1：和数据库中的数据结构保持一致，原样缓存这种场景是最常见的场景，也是很多架构使用缓存的适合，最先涉及到的场景。基本就是数据库里面啥样，我缓存也啥样，数据库里面有商品信息，缓存里面也放商品信息，唯一不同的是，数据库里面是全量的商品信息，缓存里面是最热的商品信息。每当应用要查询商品信息的时候，先查缓存，缓存没有就查数据库，查出来的结果放入缓存，从...
Java中的缓冲流
whycmpx的博客
12-21 205
1、缓冲输入流 Reader抽象类，其子类： InputStreamReader(InputStream in) 参数字节流对象，子类：FileReader(File file) 参数为File对象，FileReader(String fileName) 参数为文件路径； InputStreamReader(InputStream in,Charset cs) 参数为
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值