几种Java读写数据的流性能对比

分手后的思念是犯贱 2023-07-16 11:54 16阅读 0赞

最近关乎性能问题，网上查了查资料，这里记录一下。

近来，在做服务器后台处理数据的时候，需要用到Java自带的几种流对数据进行读写，初始时没怎么在意，就随便用了一个，结果发现性能上并不尽如人意。于是对几种常用的流做了个小小的性能测试。测试代码如下：

1 public static int FileOutputStreamTime = 0;
 2 public static int BufferedOutputStreamTime = 0;
 3 public static int FileWriterTime = 0;
 4 public static int FileInputStreamTime = 0;
 5 public static int BufferedInputStreamTime = 0;
 6 public static int FileReaderTime = 0;
 7 
 8 public static void write(String filePath, String content){
 9 FileOutputStream out = null;
 10 FileOutputStream outStr = null;
 11 BufferedOutputStream buf = null;
 12 FileWriter fw = null;
 13 File f = new File(filePath);
 14 
 15 try {
 16 //Test FileOutputStream
 17 long begin1 = System.currentTimeMillis(); 
 18 out = new FileOutputStream(f);
 19 out.write(content.getBytes());
 20 out.close();
 21 long end1 = System.currentTimeMillis();
 22 FileOutputStreamTime += end1 - begin1;
 23 
 24 //Test BufferedOutputStream
 25 long begin2 = System.currentTimeMillis();
 26 outStr = new FileOutputStream(f);
 27 buf = new BufferedOutputStream(outStr);
 28 buf.write(content.getBytes());
 29 buf.flush();
 30 buf.close();
 31 long end2 = System.currentTimeMillis();
 32 BufferedOutputStreamTime += end2 - begin2;
 33 
 34 //Test FileWriter
 35 long begin3 = System.currentTimeMillis();
 36 // the second parameter "true",Whether or not a file will be covered
 37 // or appended.
 38 fw = new FileWriter(f);
 39 // fw = new FileWriter("d:/test/testwrite/add2.txt",true);
 40 fw.write(content);
 41 fw.close();
 42 long end3 = System.currentTimeMillis();
 43 FileWriterTime += end3 - begin3;
 44 } catch (Exception e) {
 45 e.printStackTrace();
 46 } finally {
 47 try {
 48 fw.close();
 49 buf.close();
 50 outStr.close();
 51 out.close();
 52 } catch (Exception e) {
 53 e.printStackTrace();
 54 }
 55 }
 56 }
 57 
 58 public static void read(String filePath){
 59 FileInputStream in = null;
 60 BufferedInputStream buf = null;
 61 FileReader reader = null;
 62 BufferedReader br = null;
 63 StringBuffer sb = new StringBuffer();
 64 
 65 try {
 66 //Test FileInputStream
 67 long begin1 = System.currentTimeMillis();
 68 File f = new File(filePath);
 69 in = new FileInputStream(f);
 70 int len1 = 512;
 71 byte[] bytes1 = new byte[len1];
 72 
 73 while ((len1 = in.read(bytes1, 0, len1)) != -1) {
 74 if(len1 < 512){
 75 byte[] tmpBuf = new byte[len1];
 76 System.arraycopy(bytes1, 0, tmpBuf, 0, len1); 
 77 sb.append(new String(tmpBuf));
 78 tmpBuf = null;
 79 }else{
 80 sb.append(new String(bytes1));
 81 }
 82 }
 83 
 84 in.close();
 85 long end1 = System.currentTimeMillis();
 86 FileInputStreamTime += end1 - begin1;
 87 
 88 //Test BufferedInputStream
 89 long begin2 = System.currentTimeMillis();
 90 int len2 = 512;
 91 byte[] bytes2 = new byte[len2];
 92 buf = new BufferedInputStream(new FileInputStream(f));
 93 while ((len2 = buf.read(bytes2, 0, len2)) != -1) {
 94 if(len2 < 512){
 95 byte[] tmpBuf = new byte[len2];
 96 System.arraycopy(bytes2, 0, tmpBuf, 0, len2); 
 97 sb.append(new String(tmpBuf));
 98 tmpBuf = null;
 99 }else{
 100 sb.append(new String(bytes2));
 101 }
 102 }
 103 
 104 buf.close();
 105 long end2 = System.currentTimeMillis();
 106 BufferedInputStreamTime += end2 - begin2;
 107 
 108 //Test FileReader
 109 long begin3 = System.currentTimeMillis();
 110 reader = new FileReader(f);
 111 br = new BufferedReader(reader);
 112 String str;
 113 while ((str = br.readLine()) != null) {
 114 sb.append(str);
 115 }
 116 br.close();
 117 reader.close();
 118 long end3 = System.currentTimeMillis();
 119 FileReaderTime += end3 - begin3;
 120 
 121 } catch (Exception e) {
 122 e.printStackTrace();
 123 } finally {
 124 try {
 125 br.close();
 126 reader.close();
 127 in.close();
 128 buf.close();
 129 } catch (Exception e) {
 130 e.printStackTrace();
 131 }
 132 }
 133 }

测试时，分别对不同大小的数据做500次同样的操作，取得的平均耗时如下：

<table> 不同流耗时对比(ms) 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td>10K</td> 
 <td>100K</td> 
 <td>200K</td> 
 <td>400K</td> 
 </tr> 
 <tr> 
 <td>FileOutputStream</td> 
 <td>0.496</td> 
 <td>0.794</td> 
 <td>1.078</td> 
 <td>1.602</td> 
 </tr> 
 <tr> 
 <td>BufferedOutputStream</td> 
 <td>0.386</td> 
 <td>0.684</td> 
 <td>0.878</td> 
 <td>1.246</td> 
 </tr> 
 <tr> 
 <td>FileWriter</td> 
 <td>0.586</td> 
 <td>0.996</td> 
 <td>1.3</td> 
 <td>1.946</td> 
 </tr> 
 <tr> 
 <td>FileInputStream</td> 
 <td>0.158</td> 
 <td>0.544</td> 
 <td>0.984</td> 
 <td>1.876</td> 
 </tr> 
 <tr> 
 <td>BufferedInputStream</td> 
 <td>0.152</td> 
 <td>0.396</td> 
 <td>0.668</td> 
 <td>1.068</td> 
 </tr> 
 <tr> 
 <td>FileReader</td> 
 <td>0.152</td> 
 <td>0.608</td> 
 <td>1.254</td> 
 <td>2.19</td> 
 </tr> 
 </tbody> 
</table>

通过测试，可以发现，就写数据而言，**BufferedOutputStream**耗时是最短的，而性能**FileWriter**最差；读数据方面，**BufferedInputStream**性能最好，而**FileReader**性能最差劲。所以，以后在涉及到流的读写方面时，要注意一下了~

FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter。

BufferedOutputStream的数据成员buf是一个位数组，默认为512字节。当使用write()方法写入数据时，实际上会先将数据写至buf中，当buf已满时才会实现给定的OutputStream对象的write()方法，将buf数据写至目的地，而不是每次都对目的地作写入的动作。BufferedInputStream也是类似。

另外，有时只是要存储一个对象的成员数据，而不是整个对象的信息，成员数据的类型假设都是Java的基本数据类型，这样的需求不必要使用到与Object输入、输出相关的流对象，可以使用DataInputStream、DataOutputStream来写入或读出数据。在从文件中读出数据时，不用费心地自行判断读入字符串时或读入int类型时何时该停止，使用对应的readUTF()或readInt()方法就可以正确地读入完整类型数据。

在Java程序执行的过程中，很多数据都是以对象的方式存在于内存中。有时会希望直接将内存中整个对象存储至文件，而不是只存储对象中的某些基本类型成员信息，而在下一次程序运行时，希望可以从文件中读出数据并还原为对象。这时可以使用java.io.ObjectInputStream和java.io.ObjectOutputStream来进行这项工作。

ByteArrayInputStream可以将一个数组当作流输入的来源，而ByteArrayOutputStream则可以将一个位数组当作流输出的目的地。在这里举一个简单的文件位编辑程序作为例子，您可以打开一个简单的文本文件，其中有简单的A、B、C、D、E、F、G等字符，在读取文件之后，可以直接以程序来指定文件中位的位置来修改所指定的字符。作法是将文件读入数组中，指定数组索引修改元素，然后重新将数组存回文件。

java.io.Reader和java.io.Writer支持Unicode标准字符集(Character Set)(字节流则只支持ISO-Latin-1 8-bit)。在处理流数据时，会根据系统默认的字符编码来进行字符转换，Reader和Writer是抽象类，在进行文本文件的字符读写时真正会使用其子类，子类通常会重新定义相关的方法。

如果想要存取的是一个文本文件，可以直接使用java.io.FileReader和java.io.FileWriter类，它们分别继承自InputStreamReader与OutputStreamWriter。可以直接指定文件名称或File对象来打开指定的文本文件，并读入流转换后的字符，字符的转换会根据系统默认的编码(若要指定编码，则还是使用InputStreamReader与OutputStreamWriter)。

java.io.BufferedReader与java.io.BufferedWriter类各拥有8192字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并置入缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出至目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。例如一个文件，通过缓冲区可减少对硬盘的输入/输出动作，以提高文件存取的效率。

# BufferedOutputStream和ByteArrayOutputStream区别 #

今天主要是想记录下BufferedOutputStream和ByteArrayOutputStream区别  
  
众所周知BufferedOutputStream是一个缓冲数据输出流接口, ByteArrayOutputStream则是字节数组输出流接口. 这2个输出流都是我们经常用到的, 它们都是OutputStream的子类,而什么时候选择用它们呢, 这个就要看你运用到什么应用场景下了.  
  
下来先来看下源码吧.  
  
1.BufferedOutputStream会首先创建一个默认的容器量, capacity = 8192 = 8KB, 每次在写的时候都会去比对capacity是否还够用, 如果不够用的时候, 就flushBuffer(), 把buf中的数据写入对应的outputStream中, 然后将buf清空, 一直这样等到把内容写完. 在这过程中主要起到了一个数据缓冲的功能.

1.  public synchronized void write(byte b\[\], int off, int len) throws IOException \{  
2.        // 在这判断需要写的数据长度是否已经超出容器的长度了,如果超出则直接写到相应的outputStream中,并清空缓冲区  
3.        if (len >= buf.length) \{  
4.            flushBuffer();  
5.            out.write(b, off, len);  
6.            return;  
7.        \}  
8.        // 判断缓冲区剩余的容量是否还够写入当前len的内容,如果不够则清空缓冲区  
9.        if (len > buf.length - count) \{  
10.           flushBuffer();  
11.       \}  
12.       // 将要写的数据先放入内存中,等待数据达到了缓冲区的长度后,再写到相应的outputStream中  
13.       System.arraycopy(b, off, buf, count, len);  
14.       count += len;  
15.     \}

**flushBuffer () 这个方法干了些什么呢, 来看看源码**

1.  private void flushBuffer() throws IOException \{  
2.         if (count > 0) \{  
3.            // 把写入内存中的数据写到构造方法里传入的OutputStream句柄里, 并把容量大小清楚  
4.      out.write(buf, 0, count);  
5.      count = 0;  
6.         \}  
7.     \}

这个类最重要的就是这2个方法, 这样节省了大量的内存空间, 合理的分配内存来完成数据输出,当你资源不是那么充沛时, 选择这个类来实现你想要的东西是不是很合适呢?  
  
2.普通的OutputStream, 例如ByteArrayOutputStream也会首先创建一个默认的容器量, capacity = 32 = 32byte, 每次在写的时候都会去比对capacity是否还够用, 如果不够用的时候, 就重新创建buf的容量, 一直等到内容写完, 这些数据都会一直处于内存中.

/**
 * Creates a new byte array output stream. The buffer capacity is
 * initially 32 bytes, though its size increases if necessary.
 */
 public ByteArrayOutputStream() {
 this(32);
 }
 
 /**
 * Creates a new byte array output stream, with a buffer capacity of
 * the specified size, in bytes.
 *
 * @param size the initial size.
 * @exception IllegalArgumentException if size is negative.
 */
 public ByteArrayOutputStream(int size) {
 if (size < 0) {
 throw new IllegalArgumentException("Negative initial size: "
 + size);
 }
 buf = new byte[size];
 }
 
 
 /**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
 private void grow(int minCapacity) {
 // overflow-conscious code
 int oldCapacity = buf.length;
 int newCapacity = oldCapacity << 1;
 if (newCapacity - minCapacity < 0)
 newCapacity = minCapacity;
 if (newCapacity - MAX_ARRAY_SIZE > 0)
 newCapacity = hugeCapacity(minCapacity);
 buf = Arrays.copyOf(buf, newCapacity);
 }
 
 
 /**
 * Increases the capacity if necessary to ensure that it can hold
 * at least the number of elements specified by the minimum
 * capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 * @throws OutOfMemoryError if {@code minCapacity < 0}. This is
 * interpreted as a request for the unsatisfiably large capacity
 * {@code (long) Integer.MAX_VALUE + (minCapacity - Integer.MAX_VALUE)}.
 */
 private void ensureCapacity(int minCapacity) {
 // overflow-conscious code
 if (minCapacity - buf.length > 0)
 grow(minCapacity);
 }
 
 
 
 /**
 * Writes <code>len</code> bytes from the specified byte array
 * starting at offset <code>off</code> to this byte array output stream.
 *
 * @param b the data.
 * @param off the start offset in the data.
 * @param len the number of bytes to write.
 */
 public synchronized void write(byte b[], int off, int len) {
 if ((off < 0) || (off > b.length) || (len < 0) ||
 ((off + len) - b.length > 0)) {
 throw new IndexOutOfBoundsException();
 }
 ensureCapacity(count + len);
 System.arraycopy(b, off, buf, count, len);
 count += len;
 }

注释中已经对这个类进行了详细的解释  
  
总结 :

当你资源不足够用时,选择BufferedOutputStream是最佳的选择,

当你选择快速完成一个作业时,可以选择ByteArrayOutputStream之类的输出流

转自：

[https://www.cnblogs.com/Scott007/archive/2013/05/14/3078759.html][https_www.cnblogs.com_Scott007_archive_2013_05_14_3078759.html]

[https://www.iteye.com/blog/z276356445t-1955400][https_www.iteye.com_blog_z276356445t-1955400]

[https_www.cnblogs.com_Scott007_archive_2013_05_14_3078759.html]: https://www.cnblogs.com/Scott007/archive/2013/05/14/3078759.html
[https_www.iteye.com_blog_z276356445t-1955400]: https://www.iteye.com/blog/z276356445t-1955400