BufferedInputStream解读

本文主要是介绍BufferedInputStream解读，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

  咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及Java之IO流啦，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯，别被干货淹没了哦~

前言

  在进行Java编程时，避免不了要进行一些文件操作。虽然Java提供了很多类和方法来进行文件操作，但是由于I/O操作是比较费时的，所以我们需要考虑如何优化文件操作的效率。本文介绍了如何使用Java中的BufferedInputStream类来提高I/O操作的效率。

摘要

  本文主要介绍了如何使用Java中的BufferedInputStream类来优化I/O操作。首先介绍了BufferedInputStream类的作用和原理，然后分别从文件读取和文件写入两个角度，介绍了如何使用BufferedInputStream类来提高文件操作的效率。最后通过测试用例来验证了BufferedInputStream类的优化效果。

BufferedInputStream

简介

  BufferedInputStream是Java中的一个输入流，它实现了输入流的缓冲功能，使读取数据更加高效。当从一个InputStream中读取数据时，Java在内部会一次读取一个字节。这种方式读取数据的效率非常低，因为每次读取都需要和硬盘或网络进行IO操作，而这些操作非常耗时。因此，使用BufferedInputStream可以先将读取的数据缓存到内存中，在内存中慢慢读取，这样就可以减少IO操作的次数，提高读取数据的效率。在使用BufferedInputStream时，可以通过调用read()方法来读取数据，该方法会从缓冲区中读取数据，如果缓冲区中没有数据，则会调用底层流来读取数据。

作用和原理

  BufferedInputStream类是Java中的一个输入流缓冲器，它可以提高I/O操作的效率。BufferedInputStream类的原理是，当我们从文件中读取数据时，它会先将数据读入内存缓冲区中，然后再从缓冲区中逐个地读取数据。这样可以减少一些不必要的I/O操作，从而提高读取数据的效率。

优缺点

  BufferedInputStream是Java中的一个输入流包装类，它提供了输入流缓冲区的功能，可以提高读取数据的效率。

优点：

1. 提供了输入流的缓冲功能，减少了底层输入流的读取次数。这种减少I/O操作的方式可以显著提高读取数据的性能，特别是在处理大量数据时。
2. 具有预读的功能，可以一次性读取多个字节到缓冲区中，从而减少了对底层输入流的访问次数。
3. 可以通过设置合适的缓冲区大小来优化读取性能，尤其是在连续读取大型数据块时。

缺点：

1. 需要额外的内存空间来存储缓冲区，可能会占用较大的内存。
2. 当读取数据量较小时，缓冲区的额外开销可能会引起性能下降。

应用场景

1. 读取大文件或数据流时，使用BufferedInputStream可以提高读取性能。
2. 在网络传输中，可以使用BufferedInputStream来缓冲输入流，减少网络I/O的次数，提高网络传输性能。
3. 当需要连续读取大量数据块时，可以使用BufferedInputStream来将其存储在缓冲区中，减少对底层输入流的访问次数。

源码分析

  在BufferedInputStream的源码中，它维护了一个内部的字节数组缓冲区，默认缓冲区大小为8192字节（8KB）。当从BufferedInputStream中读取数据时，它会先检查缓冲区中是否还有可读取的数据，如果有，则直接从缓冲区中返回数据；如果没有，则从底层输入流中读取数据，并同时将读取的数据存入缓冲区中。在写入数据时也是类似的过程，先写入缓冲区，当缓冲区满或者需要刷新缓冲时，再将数据写入底层输出流。

  BufferedInputStream的源码比较复杂，涉及缓冲区的管理、数据读写等操作，通过内部的缓冲区来实现数据的快速读取和写入。在具体使用时，我们只需要关注使用API即可，无需深入理解其具体实现细节。

  由于BufferedInputStream主要的作用是在数据源和程序之间添加一个缓冲区，来提高IO操作的效率。读取数据时，BufferedInputStream先从缓冲区中读取，如果缓冲区中没有数据，则从数据源中读取一定量的数据放入缓冲区中，然后再从缓冲区中读取数据，这样就可以避免频繁地访问物理设备，提高了效率。

下面是BufferedInputStream的源码分析：

public class BufferedInputStream extends FilterInputStream {protected volatile byte buf[];//缓冲区大小protected int count;protected int pos;protected int markpos = -1;protected int marklimit;protected boolean mSkipLF = false;//默认缓冲区大小static int defaultBufferSize = 8192;//跳过缓冲区数据并重新读取数据private void fill() throws IOException {//pos记录缓存区的位置pos = 0;count = 0;int n = in.read(buf, pos, buf.length);if (n > 0) {//如果成功从输入流中读取数据count = n;}}//构造方法传入InputStream流对象public BufferedInputStream(InputStream in) {this(in, defaultBufferSize);}public BufferedInputStream(InputStream in, int size) {super(in);if (size <= 0) {throw new IllegalArgumentException("Buffer size <= 0");}buf = new byte[size];}//读取单个字节public synchronized int read() throws IOException {//如果当前数据已经读取完了，从输入流读取数据并缓存if (pos >= count) fill();//如果读完了还为空则返回-1return (pos < count) ? (buf[pos++] & 0xff) : -1;}//读取多个字节private int read1(byte[] b, int off, int len) throws IOException {int avail = count - pos;//如果缓存区正在被使用，则重新从流中读取数据到缓冲区中if (avail <= 0) {if (len >= buf.length && markpos < 0) {return in.read(b, off, len);}fill();avail = count - pos;if (avail <= 0) return -1;}int cnt = (avail < len) ? avail : len;System.arraycopy(buf, pos, b, off, cnt);pos += cnt;return cnt;}//读取多个字节，并返回读取的字节数public synchronized int read(byte b[], int off, int len)throws IOException {//校验参数范围if (b == null) {throw new NullPointerException();} else if (off < 0 || len < 0 || len > b.length - off) {throw new IndexOutOfBoundsException();} else if (len == 0) {return 0;}int n = 0;//连续读取for (;;) {int nread = read1(b, off + n, len - n);if (nread <= 0) return (n == 0) ? nread : n;n += nread;//读够了就退出循环if (n >= len) return n;}}//跳过指定字节数public synchronized long skip(long n) throws IOException {if (n <= 0) {return 0;}//现将缓存区的数据跳过long avail = count - pos;if (avail <= 0) {//如果缓存区没有数据，则直接跳过n个字节return in.skip(n);}long skipped = (avail < n) ? avail : n;pos += skipped;n -= skipped;//如果还需要跳过的字节数超过了缓存区大小，则直接调用输入流的skip方法跳过if (n > 0) {skipped += in.skip(n);}return skipped;}//返回当前可读取的字节数public synchronized int available() throws IOException {int n = count - pos;int avail = in.available();return (n > (Integer.MAX_VALUE - avail)) ? Integer.MAX_VALUE : n + avail;}//标记当前位置public synchronized void mark(int readlimit) {marklimit = readlimit;markpos = pos;}//重置到上一次标记的位置public synchronized void reset() throws IOException {if (markpos < 0) {throw new IOException("Resetting to invalid mark");}pos = markpos;}//判断是否支持mark和reset方法public boolean markSupported() {return true;}//关闭流public void close() throws IOException {byte[] buffer;synchronized (this) {buffer = buf;buf = null;}if (buffer != null) {//调用输入流的close方法关闭流in.close();}}
}

  从源码中可以看出，BufferedInputStream主要是通过缓冲区来提高了读取效率，其读取过程与InputStream的读取过程基本一致，只不过在数据从输入流中读取后，会先将其缓存到一个缓冲区中，然后再从缓冲区中读取数据。同时，BufferedInputStream还提供了mark和reset方法，可以对数据流进行标记和重置，方便对流的操作。

使用BufferedInputStream类读取文件

  在进行文件读取时，我们可以使用BufferedInputStream类来提高读取效率。下面是一个使用BufferedInputStream类读取文件的示例代码：

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("./template/hello.txt"))) {byte[] buffer = new byte[1024];int length;while ((length = bis.read(buffer)) != -1) {// do something with the data}
} catch (IOException e) {// handle exception
}

  上面的代码中，我们首先创建了一个BufferedInputStream对象，并将其包装在一个try-with-resources语句中，这样可以自动关闭资源。然后我们创建一个字节数组作为缓冲区，读取文件时每次读取1024个字节，读取到文件末尾时返回-1。我们可以在while循环中对读取到的数据进行处理。

  使用BufferedInputStream类读取文件时，每次读取的数据会先被读入缓冲区中，当缓冲区的数据被读取完后，再从文件中读取新的数据。这样可以减少I/O操作的次数，提高读取数据的效率。

使用BufferedInputStream类写入文件

  在进行文件写入时，我们同样可以使用BufferedInputStream类来提高写入效率。下面是一个使用BufferedInputStream类写入文件的示例代码：

try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("./template/hello.txt"))) {byte[] data = "Hello, jym! ".getBytes();bos.write(data);
} catch (IOException e) {// handle exception
}

  上面的代码中，我们首先创建了一个BufferedOutputStream对象，并将其包装在一个try-with-resources语句中，这样可以自动关闭资源。然后我们将要写入的数据转换成字节数组，并通过BufferedOutputStream对象将数据写入到文件中。

  使用BufferedInputStream类写入文件时，每次写入的数据会先被写入到缓冲区中，当缓冲区的数据写满后，再将缓冲区中的数据一次性写入到文件中。这样可以减少I/O操作的次数，提高写入数据的效率。

测试用例

代码演示

  为了验证BufferedInputStream类的优化效果，我们可以编写一个测试用例。下面是一个使用BufferedInputStream类读取文件的测试用例：

package com.example.javase.io.bufferedInputStream;import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;/*** @author bug菌* @version 1.0* @date 2023/10/13 17:51*/
public class BufferedInputStreamTest {public static void main(String[] args) {long start = System.currentTimeMillis();try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("./template/hello.txt"))) {byte[] buffer = new byte[1024];int length;while ((length = bis.read(buffer)) != -1) {String content = new String(buffer, 0, length);System.out.println("读取内容为：" + content);}} catch (IOException e) {// handle exception}long end = System.currentTimeMillis();System.out.println("Time used: " + (end - start) + "ms");}
}

  上面的代码中，我们首先记录了开始时间，然后使用BufferedInputStream类读取文件，并在while循环中对读取到的数据进行处理。最后，在读取数据时，将字节数组转换为字符串，并使用 System.out.println() 方法打印出来；并记录了结束时间，并输出总共使用的时间。

  我们可以在不使用BufferedInputStream类的情况下编写一个相同的测试用例，然后比较两个测试用例的运行时间，从而验证BufferedInputStream类的优化效果。

测试代码解析

这段代码演示了如何使用BufferedInputStream读取文件内容。

1. 首先导入需要的类，包括BufferedInputStream、FileInputStream、IOException等；

2. 在main函数中，首先记录程序开始的时间；

3. 使用try-with-resources语句创建一个BufferedInputStream对象，它包装了一个FileInputStream对象，用于读取指定路径下的hello.txt文件；

4. 创建一个byte数组作为缓冲区，长度为1024；

5. 使用while循环读取文件内容，每次读取的数据被存储在缓冲区中，长度由read()方法返回；

6. 将从缓冲区中读取的字节转换为字符串，输出到控制台；

7. catch IOException异常，处理异常；

8. 记录程序结束的时间；

9. 输出程序执行时间。

  需要注意的是，使用BufferedInputStream可以提高读取文件的效率，但在读取大文件时，可能会导致内存溢出，需要注意调整缓冲区的大小。

测试结果

如下是运行测试用例所得截图，仅供参考：

小结

  通过本文的介绍，我们了解了如何使用Java中的BufferedInputStream类来提高I/O操作的效率。我们可以使用BufferedInputStream类来读取文件和写入文件，达到减少I/O操作次数、提高效率的目的。同时我们还编写了一个测试用例来验证BufferedInputStream类的优化效果。

总结

  BufferedInputStream类是Java中的一个输入流缓冲器，它可以提高I/O操作的效率。我们可以使用BufferedInputStream类来读取文件和写入文件，达到减少I/O操作次数、提高效率的目的。通过编写测试用例，我们验证了BufferedInputStream类的优化效果。在进行文件操作时，我们可以尽可能使用BufferedInputStream类来提高效率。

这篇关于BufferedInputStream解读的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---