Improve I/O performance through the buffer in Java

We know that the input and output stream classes in Java use a single-byte read method to perform I/O operations. That is to say, each read-only write of one byte of data, this method is obviously cumbersome and inefficient. If you read 10 MB of files from a device and read one byte each time, you will need to perform 10 MB of I/O operations. I/O operations are quite time-consuming, undoubtedly, the system performance is greatly reduced.

 

 

Java code {
DP. Sh. toolbar. copytoclipboard (this); Return false;
} "Href =" http://writeblog.csdn.net/# ">

1. ImportJava. Io .*;
3. /*************************************** ****************************************
4. *
5. * @ Author pengcqu
6. *
7. */
8. Public ClassTestbuffer {
10. Public Static VoidMain (string ARGs [])ThrowsIoexception {
11. Testbuffer BR =NewTestbuffer ();
12. String from = "D:/A/1. MP3 ";
13. LongStarttime = system. currenttimemillis ();
14. BR. readwrite (from, "d:/B/2. MP3 ");
15. LongEndtime = system. currenttimemillis ();
16. System. Out. println ("direct read time:" + (endtime-starttime) + "Ms ");
17. LongStarttime1 = system. currenttimemillis ();
18. BR. readwritewithbuffer (from, "d:/B/3. MP3 ");
19. LongEndtime1 = system. currenttimemillis ();
20. System. Out. println ("Time consumed to read using the buffer:" + (endtime1-starttime1) + "Ms ");
23. }
25. /*************************************** ************************************
26. * Directly read files
27. *
28. * @ Param from
29. * @ Param
30. * @ Throws ioexception
31. */
32. Public Static VoidReadwrite (string from, string)ThrowsIoexception {
33. Inputstream in =Null;
34. Outputstream out =Null;
35. Try{
36. In =NewFileinputstream (from );
37. Out =NewFileoutputstream ();
38. While(True){
39. IntData = in. Read ();
40. If(Data =-1 ){
41. Break;
42. }
43. Out. Write (data );
44. }
45. }Finally{
46. If(In! =Null){
47. In. Close ();
48. }
49. If(Out! =Null){
50. Out. Close ();
51. }
52. }
53. }
55. /*************************************** ************************************
56. * Use the cache area to read and write files
57. * @ Param from
58. * @ Param
59. * @ Throws ioexception
60. */
61. Public Static VoidReadwritewithbuffer (string from, string)
62. ThrowsIoexception {
63. Inputstream inbuffer =Null;
64. Outputstream outbuffer =Null;
65. Try{
66. Inbuffer =NewBufferedinputstream (NewFileinputstream (from ));
67. Outbuffer =NewBufferedoutputstream (NewFileoutputstream ());
68. While(True){
69. IntData = inbuffer. Read ();
70. If(Data =-1 ){
71. Break;
72. }
73. Outbuffer. Write (data );
74. }
75. }Finally{
76. If(Inbuffer! =Null){
77. Inbuffer. Close ();
78. }
79. If(Outbuffer! =Null){
80. Outbuffer. Close ();
81. }
82. }
83. }
85. }

Import Java. io. *; /*************************************** **************************************** ** @ author pengcqu **/public class testbuffer {public static void main (string ARGs []) throws ioexception {testbuffer BR = new testbuffer (); string from = "D:/A/1. MP3 "; long starttime = system. currenttimemillis (); BR. readwrite (from, "d:/B/2. MP3 "); long endtime = system. currenttimemillis (); system. out. printl N ("direct read time:" + (endtime-starttime) + "Ms"); long starttime1 = system. currenttimemillis (); BR. readwritewithbuffer (from, "d:/B/3. MP3 "); long endtime1 = system. currenttimemillis (); system. out. println ("buffer reading time consumed:" + (endtime1-starttime1) + "Ms ");} /*************************************** * ************************************ directly read the file ** @ Param from * @ Param to * @ throws ioexception */public static void rea Dwrite (string from, string to) throws ioexception {inputstream in = NULL; outputstream out = NULL; try {In = new fileinputstream (from); out = new fileoutputstream (); while (true) {int DATA = in. read (); If (Data =-1) {break;} Out. write (data) ;}} finally {If (in! = NULL) {in. Close () ;}if (OUT! = NULL) {out. close ();}}} /*************************************** * ************************************ use the cache Zone read/write files * @ Param from * @ Param to * @ throws ioexception */public static void readwritewithbuffer (string from, string to) throws ioexception {inputstream inbuffer = NULL; outputstream outbuffer = NULL; try {inbuffer = new bufferedinputstream (New fileinputstream (from); outbuffer = new bufferedoutputs Tream (New fileoutputstream (to); While (true) {int DATA = inbuffer. read (); If (Data =-1) {break;} outbuffer. write (data) ;}} finally {If (inbuffer! = NULL) {inbuffer. Close ();} If (outbuffer! = NULL) {outbuffer. Close ();}}}}

Result: for a file of the size of 39266 MB, the direct read/write time is 719 ms, and the buffer read/write time is ms. It can be seen that the performance of reading and writing files through buffer is significantly better than that of direct reading and writing.

Java provides a buffer class to improve the I/O efficiency. This is like a temporary buffer for reading and writing data in a buffer every time and writing the database to the target device at a time. There are two reading methods.

 

For example, there are 10000 books in a that need to be moved to B. If one book is moved at a time, it will take 10000 times. If you place 1000 yuan each time on a freight car and ship it to location B, it takes 10 times to complete. The freight car is equivalent to the cache zone. Similarly, opening a data cache area to read data blocks at a time significantly improves reading efficiency. The following uses a specific code example to show the performance differences between the two.