Java基础-IO流（缓冲流）

已于 2022-10-22 12:13:34 修改
阅读量342 收藏
点赞数
分类专栏： java 文章标签： java
于 2022-10-22 11:59:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50369190/article/details/127457536
版权

文章目录

前言

能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，相当于是对基本流对象的一种增强。

缓冲流是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：
字节缓冲流： BufferedInputStream ， BufferedOutputStream
字符缓冲流： BufferedReader ， BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
在这里插入图片描述

提示：以下是本篇文章正文内容，下面案例可供参考

一、字节缓冲流

1. 字节输出缓冲流（写出）

BufferedOutputStream 继承OutputStream,操作时还是使用OutputStream的write方法。
构造方法:
BufferedOutputStream​(OutputStream out) 参数要一个基本的流，最终靠基本的流去操作文件。

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * 字节输出缓冲流（写）
 * new 缓冲流（new 基本流）
 */
public class demo01 {
    public static void main(String[] args) throws Exception {
        /**
         * 参数要一个基本的流，最终靠基本的流去操作文件
         */
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day_11/src/com/hntou/IO/Output/a.txt"));
        /**
         * 追加 BufferedOutputStream 的构造方法第二个参数没有boolean类型
         * 所以追加模式的true需要加载原来流上加
         */
        //BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day_11/src/com/hntou/IO/Output/a.txt",true));
        //写出一个字节
        bos.write(97);
        //写出一个字节数组
        byte[] bytes = {65,66,67,68};
        bos.write(bytes);
        //写出一个字节数组的一部分
        bos.write(bytes,0,2);
        //关闭流(不然会丢失数据)
        bos.close();
    }
}

2. 字节输入缓冲流（读入）

BufferedInputStream 继承InputStream，操作还是使用InputStream的read方法。
构造方法:BufferedInputStream​(InputStream in) 参数要一个基本的流，靠基本的流去操作文件。

2.1 输入一个字节

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 输入缓冲流（读）
 * new 换冲流（new基本流）
 */
public class demo01 {
    public static void main(String[] args) throws Exception {
        //1.创建缓冲输入流
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream("day_11/src/com/hntou/IO/Output/a.txt"));
        //2.读数据
        System.out.println((char) bis.read());
        //3.关闭流
        bis.close();
    }
}

2.2 循环输入一个字节

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 循环读取一个字节
 */
public class demo02 {
    public static void main(String[] args) throws Exception {
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream("day_11/src/com/hntou/IO/Output/a.txt"));
        int ch;
        while((ch=bis.read())!=-1){
            System.out.print((char) ch);
        }
    }
}

2.3 输入一个字节数组

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 读取一个字节数组
 */
public class demo03 {
    public static void main(String[] args) throws Exception {
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream("day_11/src/com/hntou/IO/Output/a.txt"));
        byte[] bytes = new byte[2];
        int len = bis.read(bytes);
        String str = new String(bytes,0,len);
        System.out.println(str);
        bis.close();
    }
}

2.4 循环输入一个字节数组

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 循环读取一个字节数组
 */
public class demo04 {
    public static void main(String[] args) throws Exception {
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream("day_11/src/com/hntou/IO/Output/a.txt"));
        byte[] bytes = new byte[2];
        int len;
        /**
         * 每次读两个存入缓冲区
         */
        while((len =bis.read(bytes))!=-1){
            System.out.print(new String(bytes,0,len));
        }
    }
}

二、字符缓冲流

1. 字符输出缓冲流（写出）

BufferedWriter 继承了Writer，可以使用父类Writer中的write方法。
构造方法: BufferedWriter​(Writer out) 参数要传入基本流，靠基本流来操作文件。
特有方法：newline() 换行

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 字符输出缓冲流（写）
 */
public class demo01 {
    public static void main(String[] args) throws Exception {
        //创建字符输出缓冲流
        BufferedWriter bw = new BufferedWriter(new FileWriter("day_11/src/com/hntou/IO/Reader/b.txt"));
        //写出一个字符
        bw.write(97);
        //换行(字符缓冲输出流独有方法)
        bw.newLine();
        //写出字符数组
        char[] chars = {97,98,99,100};
        bw.write(chars);
        //写出字符数组的一部分
        bw.write(chars,0,2);
        bw.newLine();
        //写出字符串
        bw.write("字符串");
        //关闭流
        bw.close();
    }
}

2. 字符输入缓冲流（读入）

BufferedReader 继承了Reader，可以使用父类Reader中的read方法。
构造方法: BufferedReader(Reader in) 参数要传入基本流，靠基本流来操作文件。
特有方法：String readLine() 读取一行数据返回，读不到时返回null。

1.1 输入一个字符

import java.io.BufferedReader;
import java.io.FileReader;
/**
 * 字符输入缓冲流（读）
 */
public class demo01 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("day_11/src/com/hntou/IO/Reader/b.txt"));
        //读取一个字符
        System.out.println((char) br.read());
        br.close();
    }
}

1.2 循环输入一个字符

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

/**
 * 循环读取一个字符
 */
public class demo02 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("day_11/src/com/hntou/IO/Reader/b.txt"));
        //循环读取一个字符
        int ch;
        while ((ch = br.read()) != -1) {
            System.out.print((char) ch);
        }
        br.close();
    }
}

1.3 输入一个字符数组

/**
 * 读取一个字符数组
 */
public class demo03 {
    public static void main(String[] args) throws  Exception {
        BufferedReader br = new BufferedReader(new FileReader("day_11/src/com/hntou/IO/Reader/b.txt"));
        char[] chars = new char[2];
        int len = br.read(chars);
        String str = new String(chars,0,len);
        System.out.println(str);
        br.close();
    }
}

1.4 循环输入一个字符数组

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

/**
 * 循环读取一个字符数组
 */
public class demo04  {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("day_11/src/com/hntou/IO/Reader/b.txt"));
        char[] chars = new char[2];
        int len;
        while((len = br.read(chars))!=-1){
            System.out.print(new String(chars,0,len));
        }
        br.close();
    }
}

1.5 独有方法readLine（）

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

/**
 * 读取一行
 */
public class demo05 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("day_11/src/com/hntou/IO/Reader/b.txt"));
        //System.out.println(br.readLine());
        /**
         * 循环读取一行，读不到返回null
         */
        String s;
        while((s= br.readLine())!=null){
            System.out.println(s);
        }
        br.close();
    }
}

三、字符流解析文件案例

需求：
解析出“用户列表.txt”文件中的用户姓名和年龄，封装成User对象，保存到集合中，并对年龄进行升序排序。
分析：
创建字符输入缓冲流BufferedReader。
定义User类，提供name和age属性。
循环读取一行数据，将每行数据切割出姓名和年龄，每行数据对应一个User对象。
创建ArrayList集合，存储User对象。
使用Collections工具类实现集合元素升序排序。
在这里插入图片描述

public class User {
    private String name;
    private Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Collections;

/**
 * 使用字符流解析文件
 *
 * 解析出“用户列表.txt”文件中的用户姓名和年龄，封装成User对象，保存到集合中，并对年龄进行升序排序。
 * 分析：
 * 创建字符输入缓冲流BufferedReader。
 * 定义User类，提供name和age属性。
 * 循环读取一行数据，将每行数据切割出姓名和年龄，每行数据对应一个User对象。
 * 创建ArrayList<User>集合，存储User对象。
 * 使用Collections工具类实现集合元素排序。
 */
public class demo01 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("day_11/src/com/hntou/IO/Case/user.txt"));
        ArrayList<User> list = new ArrayList<>();
        String s;
        while ((s=br.readLine())!=null){
            //读取一行之后分割数据 张三 18
            String[] split = s.split("=");
            //创建User对象加入集合
            //因为User构造方法第二个参数是Integer类型，分割出来的是字符串类型，所以需要包装为Integer类型
            list.add(new User(split[0],Integer.valueOf(split[1])));
        }
        br.close();
        Collections.sort(list,(o1,o2)->o1.getAge()-o2.getAge());
        System.out.println(list);
    }
}

四、缓冲流性能对比案例

需求：使用四种方式完成文件复制（测试数据为1M）
在这里插入图片描述

字节流四种方式复制文件:
基本流读取一个字节&&缓冲流读取一个字节

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopyDemo {
    public static void main(String[] args) throws Exception {
        //测试运行效率
        long start = System.currentTimeMillis();
        test1();
        //test2();
        long end = System.currentTimeMillis();
        System.out.println(end-start+"ms");
    }

    //基本流读写一个字节(桌面拷贝到当前项目路径下)
    public static void test1() throws Exception{
        //读
        FileInputStream fis = new FileInputStream("/Users/hebinyang/Desktop/test.pdf");
        //写
        FileOutputStream fos = new FileOutputStream("day_11/src/com/hntou/IO/Case/test.pdf");
        int ch ;
        while((ch=fis.read())!=-1){
            fos.write(ch);
        }
        fis.close();
        fos.close();
    }
    //缓冲流读写一个字节（桌面拷贝到当前项目路径下）
    public static void test2() throws Exception{
        //读
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("/Users/hebinyang/Desktop/test.pdf"));
        //写
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("day_11/src/com/hntou/IO/Case/test.pdf"));
        byte[] bytes = new byte[1024];
        int len;
        while((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

字节基本流一次一个字节copy一个1.4M的文件用了3064ms
在这里插入图片描述

字节缓冲流一次一个字节copy一个1.4M的文件用了6ms
在这里插入图片描述

基本流读取一个字节数组&&字节缓冲流读取一个字节数组

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopyDemo {
    public static void main(String[] args) throws Exception {
        //测试运行效率
        long start = System.currentTimeMillis();
        //test3();
        //test4();
        long end = System.currentTimeMillis();
        System.out.println(end-start+"ms");
    }
    //基本流读写一个字节数组（桌面拷贝到当前项目路径下）
    public static void test3() throws  Exception{
        //读
        FileInputStream fis = new FileInputStream("/Users/hebinyang/Desktop/test.pdf");
        //写
        FileOutputStream fos = new FileOutputStream("day_11/src/com/hntou/IO/Case/test.pdf");
        byte[] bytes = new byte[1024];
        int len;
        while((len=fis.read(bytes))!=-1){
            fos.write(bytes);
        }
        fis.close();
        fos.close();
    }

    //缓冲流读写一个字节数组（桌面拷贝到当前项目路径下）
    public static void test4() throws Exception{
        //读
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("/Users/hebinyang/Desktop/test.pdf"));
        //写
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("day_11/src/com/hntou/IO/Case/test.pdf"));
        byte[] bytes = new byte[1024];
        int len;
        while((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

基本流读取一个字节数组用了9ms
在这里插入图片描述
这里可以发现基本流用数组读写已经比单个字节读写效率提升很多了。
缓冲流读取一个字节数组用了6ms
在这里插入图片描述
这里可以发现读写字符数组无论是缓冲流还是基本流的差距不是很大。

五、总结

1.缓冲流性能对比：

  • 一个文件每次读写一个字节，使用缓冲流，可以明显提高效率。
  • 一个文件每次读写一个字节数组，基本流和缓冲流的差别不大。
  • 缓冲流续写效率高，尽量使用缓冲流去代替基本流的使用。

2.字符缓冲流为什么提高了操作数据的性能。

  • 字符缓冲流自带8K的缓冲区
  • 可以提高原始自负流读写数据的性能。
  • 字符缓冲流的新增功能。（public BufferedReader(Reader r) 多个readLine() 按照行读取的功能。 public BufferedWriter(Writer w) 多了newLine() 换行的功能。）
宁愿一生都不说话
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java核心基础编程精讲-IO流
06-21
从零开始学习Java核心基础编程精讲 本章主要为大家介绍IO流，让学员快速熟悉文件操作File类，IO流_节点流、缓冲流、转换流、对象流。课件在最后一节旁边下载，有什么问题可私信我，祝学习愉快
BufferedInputStream & BufferedOutputStream用法
关于代码的那些事
03-01 1545
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.net.HttpURLConnection; import jav
Java - 缓冲输入输出流 (BufferedInputStream、BufferedOutputStream）
weixin_48591974的博客
11-30 2132
Java - 缓冲输入输出流 (BufferedInputStream、BufferedOutputStream）
Java中BufferedInputStream和BufferedOutputStream基本使用详解
热门推荐
刘先森
10-03 5万+
BufferedInputStream的使用 BufferedInputStream:缓冲字节输入流，是一个高级流(处理流)，与其他低级流配合使用。 构造方法//创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个内部缓冲区数组并将其存储在 buf 中,该buf的大小默认为8192。 public BufferedInputStream(Inpu
字节缓冲输入流(BufferedInputStream）
yuan_boss的博客
06-09 829
字节缓冲输入流(BufferedInputStream） 该类继承FilterInputStream BufferedInputStream是一个比FileInputStream更粗的管道，该管道的构造方法的参数是InputStream类型的，所以在铺设该粗管道之前，应该先铺设一个InputStream类型的细管道，再将此细管道对象传入粗管道的参数之中 输入准备：有个水厂，有小车 BufferedInputStream输入逻辑： 1.new一个InputStream类型的对象 nputStream fis
File类、IO流
m0_47982122的博客
03-19 348
一、File类 1、含义：文件和目录路径名的抽象表示 2、File（String pathname） 通过将给定的路径名字字符串转换为抽象路径名来创建新的File实例 表示路径的字符串中，路径的分隔符可以使用\,/,// 但是在系统目录中默认使用\表示路径分隔 二、IO流 1、含义：数据的读入写出,文件的上传下载 2、流 含义：一连串流动的数据,以先入先出的方式进行传输–>流就是管道 分类 （1）操作单元分 字节流 万能流 字符流 纯文本内容 （2）流向分 以程序为中心 输入流 输出流 （3）功能分
Java Day21
Trony的博客
07-29 188
第一章 缓冲流 1.1 概述 缓冲流也叫做高效流，是对4个基本的FileXxx流的增强，所以也是4个类，按照数据类型分类： 字节缓冲流：BufferedInputStream、BufferedOutputStream 字符缓冲流：BufferedReader、BufferedWriter 缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。 1.2 字节缓冲流 1.2.1 构造方法 public BufferedInp
javaIO流之缓冲流
恒二哥的博客
05-19 2318
Java 的缓冲流是对字节流和字符流的一种封装，通过在内存中开辟缓冲区来提高 I/O 操作的效率。Java 通过 BufferedInputStream 和 BufferedOutputStream 来实现字节流的缓冲，通过 BufferedReader 和 BufferedWriter 来实现字符流的缓冲。缓冲流的工作原理是将数据先写入缓冲区中，当缓冲区满时再一次性写入文件或输出流，或者当缓冲区为空时一次性从文件或输入流中读取一定量的数据。
2021-09-15
weixin_44957755的博客
09-15 165
1. I/O系统 I/O： 输入输出，其实就是一套API，通过它可以从硬盘、网络、键盘等地方读取数据，也可以将内容写入到硬盘、网络、屏幕等地方。 I/O是程序获取和交换数据的主要渠道，I/O很容易成为性能瓶颈。 Java在I/O上一直在做持续的优化，1.4开始引入了非阻塞I0（NIO，其实网络IO是同步非阻塞的，文件IO依旧是同步阻塞的)，1.7引入了异步IO(AIO) IO： 同步阻塞的BIO BIO是面向流的、阻塞式的、串行的一个过程。 阻塞是线程的一种状态，当线程执行了IO相关的读写方法后，在操作
Java中io流的学习（三）BufferedInputStream和BufferedOutputStream
有问题请发邮箱[email protected]进行讨论
08-16 2832
BuffereInputStream（带有缓冲区的字节输入流）继承于FilterInputStream，而FilterInputStream继承于InputStream，BuffereOutputStream（带有缓冲区的字节输出流）继承于FilterOutputStream，而FilterOutputStream继承于OutputStream，关于FilterInputStream和Filter...
详解java IO流之缓冲流的使用
08-31
本文主要介绍了java的IO流中的缓冲流的使用，缓冲流分为字节和字符缓冲流。分享了有关它们的实例代码，具有一定的参考价值，下面跟着小编一起来看下吧
Java IO字符流缓冲区实现原理解析
08-19
主要介绍了Java IO字符流缓冲区实现原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
java使用BufferedInputStream&BufferedOutputStream字节流读写文件
qq_43960768的博客
03-01 1199
BufferedInputStream读取文件
BufferedInputStream
怡世的盒子
07-24 268
package cn.itcast.demo1; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.IOException; /* * 字节输入流的缓冲流 * java.io.BufferedInputStream * 继承InputStream,标准的字节输入流...
Java I/O 教程（六） BufferedInputStream 类
老徐的博客只有干货
01-01 1813
Java BufferedInputStream Class Java BufferedInputStream class 用于从输入流读取数据，和BufferedOutStream一样内部使用缓冲机制提高读取性能。 需要注意的是: 当读取流中字节时，内部缓冲区每次会自动重新填满多个字节。 当一个缓冲输入流创建时，一个内部缓冲区数组也会创建。 类定义
Java IO流 处理流--缓冲流(Buffering)
天行健 君子以自强不息，地势坤 君子以厚德载物。
08-04 2002
1. 缓冲流(Buffering) 缓冲流要”套接“在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。Java提供了四种缓冲流，常用构造方法如下： 缓冲输入流支持其父类的mark和reset方法。 BufferedReader提供了readLine方法用于读取一行字符串 BufferedWriter提供了newLine用于写入一个行分隔符 对于输出的缓冲流，写出的数据会现在内存中缓存，使用flush方法将会使内存中的数据立刻写出 带有缓冲区的，缓冲区(Buffe
缓冲流（BufferedInputStream，BufferedOutputStream\BufferedReader，BufferedWriter）
Valentino112358的博客
05-14 253
缓冲流的原理 昨天学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。 缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类： 字节...
java高级特性 - io流
最新发布
05-24
Java的IO流还支持缓冲区和管道流等高级特性。缓冲区可以提高IO流的效率，管道流可以实现进程间的数据传输。 在使用Java的IO流时，需要注意及时关闭流，避免资源浪费和文件读写错误。可以使用try-with-resources语句...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值