JAVA之NIO按行读写大文件，完美解决中文乱码问题

灰太狼 2022-09-23 08:56 161阅读 0赞

[JAVA之NIO按行读写大文件，完美解决中文乱码问题][JAVA_NIO]

转载URL ： http://blog.csdn.net/v123411739/article/details/50620289

# 前言 #

最近在开发的时候，接到了一个开发任务，要将百万行级别的txt数据插入到数据库中，由于内存方面的原因，因此不可能一次读取所有内容，后来在网上找到了解决方法，可以使用[NIO][]技术来处理，于是找到了这篇文章[http://www.sharejs.com/codes/java/1334][http_www.sharejs.com_codes_java_1334]，后来在试验过程中发现了一点小bug，由于是按字节读取，汉字又是2个字节，因此会出现汉字读取“一半”导致乱码的情况，于是花了几天时间将这个问题解决了。

# 例子 #

假设我们一次读取的字节是从下图的start到end，因为结尾是汉字，所以有几率出现上述的情况。

解决方法如下：将第9行这半行(第9行阴影的部分)跟上一次读取留下来的半行(第9行没阴影的部分)按顺序存放在字节数组，然后转成字符串；中间第10行到第17行正常转换成字符串；第18行这半行(第18行阴影的部分)留着跟下一次读取的第1行(第18行没阴影的部分)连接成一行，因为是先拼接成字节数组再转字符串，因此不会出现乱码的情况。

![Center][]

# 代码 #

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **import** java.io.File;  
2.  **import** java.io.IOException;  
3.  **import** java.io.RandomAccessFile;  
4.  **import** java.nio.ByteBuffer;  
5.  **import** java.nio.channels.FileChannel;  
6.  **import** java.util.Date;  
7.    
8.  **public** **class** TestNIO3 \{  
9.    
10.     **public** **static** **void** main(String args\[\]) **throws** Exception \{  
11.   
12.         **int** bufSize = 1000000;//一次读取的字节长度  
13.         File fin = **new** File("D:\\\\test\\\\20151224\_1375789.txt");//读取的文件  
14.         File fout = **new** File("D:\\\\test\\\\111111111111111111.txt");//写出的文件  
15.         Date startDate = **new** Date();  
16.         FileChannel fcin = **new** RandomAccessFile(fin, "r").getChannel();  
17.         ByteBuffer rBuffer = ByteBuffer.allocate(bufSize);  
18.   
19.         FileChannel fcout = **new** RandomAccessFile(fout, "rws").getChannel();  
20.         ByteBuffer wBuffer = ByteBuffer.allocateDirect(bufSize);  
21.   
22.         readFileByLine(bufSize, fcin, rBuffer, fcout, wBuffer);  
23.         Date endDate = **new** Date();  
24.           
25.         System.out.print(startDate+"|"\+endDate);//测试执行时间  
26.     \}  
27.   
28.     **public** **static** **void** readFileByLine(**int** bufSize, FileChannel fcin,  
29.             ByteBuffer rBuffer, FileChannel fcout, ByteBuffer wBuffer) \{  
30.         String enterStr = "\\n";  
31.         **try** \{  
32.             **byte**\[\] bs = **new** **byte**\[bufSize\];  
33.             //temp：由于是按固定字节读取，在一次读取中，第一行和最后一行经常是不完整的行，因此定义此变量来存储上次的最后一行和这次的第一行的内容，  
34.             //并将之连接成完成的一行，否则会出现汉字被拆分成2个字节，并被提前转换成字符串而乱码的问题，数组大小应大于文件中最长一行的字节数  
35.             **byte**\[\] temp = **new** **byte**\[500\];  
36.             **while** (fcin.read(rBuffer) != -1) \{  
37.                 **int** rSize = rBuffer.position();  
38.                 rBuffer.rewind();  
39.                 rBuffer.get(bs);  
40.                 rBuffer.clear();  
41.                   
42.                 //windows下ascii值13、10是换行和回车，unix下ascii值10是换行  
43.                 //从开头顺序遍历，找到第一个换行符  
44.                 **int** startNum=0;  
45.                 **int** length=0;  
46.                 **for**(**int** i=0;i<rSize;i++)\{  
47.                     **if**(bs\[i\]==10)\{ //找到换行字符  
48.                         startNum=i;  
49.                         **for**(**int** k=0;k<500;k++)\{  
50.                             **if**(temp\[k\]==0)\{ //temp已经存储了上一次读取的最后一行，因此遍历找到空字符位置，继续存储此次的第一行内容，连接成完成一行  
51.                                 length=i+k;  
52.                                 **for**(**int** j=0;j<=i;j++)\{  
53.                                     temp\[k+j\]=bs\[j\];  
54.                                 \}  
55.                                 **break**;  
56.                             \}  
57.                         \}  
58.                         **break**;  
59.                     \}  
60.                 \}  
61.                 //将拼凑出来的完整的一行转换成字符串  
62.                 String tempString1 = **new** String(temp, 0, length+1, "GBK");  
63.                 //清空temp数组  
64.                 **for**(**int** i=0;i<temp.length;i++)\{  
65.                     temp\[i\]=0;  
66.                 \}  
67.                 //从末尾倒序遍历，找到第一个换行符  
68.                 **int** endNum=0;  
69.                 **int** k = 0;  
70.                 **for**(**int** i=rSize-1;i>=0;i--)\{  
71.                     **if**(bs\[i\]==10)\{  
72.                         endNum=i;//记录最后一个换行符的位置  
73.                         **for**(**int** j=i+1;j<rSize;j++)\{  
74.                             temp\[k++\]=bs\[j\];//将此次读取的最后一行的不完整字节存储在temp数组，用来跟下一次读取的第一行拼接成完成一行  
75.                             bs\[j\]=0;  
76.                         \}  
77.                         **break**;  
78.                     \}  
79.                 \}  
80.                 //去掉第一行和最后一行不完整的，将中间所有完整的行转换成字符串  
81.                 String tempString2 = **new** String(bs, startNum+1, endNum-startNum, "GBK");  
82.                   
83.                 //拼接两个字符串  
84.                 String tempString = tempString1 + tempString2;  
85. //              System.out.print(tempString);  
86.                   
87.                 **int** fromIndex = 0;  
88.                 **int** endIndex = 0;  
89.                 **while** ((endIndex = tempString.indexOf(enterStr, fromIndex)) != -1) \{  
90.                     String line = tempString.substring(fromIndex, endIndex)+enterStr;//按行截取字符串  
91.                     System.out.print(line);  
92.                     //写入文件  
93.                     writeFileByLine(fcout, wBuffer, line);  
94.   
95.                     fromIndex = endIndex + 1;  
96.                 \}  
97.             \}  
98.         \} **catch** (IOException e) \{  
99.             e.printStackTrace();  
100.         \}  
101.     \}  
102.   
103.     /\*\* 
104.      \* 写到文件上 
105.      \* @param fcout 
106.      \* @param wBuffer 
107.      \* @param line 
108.      \*/  
109.     @SuppressWarnings("static-access")  
110.     **public** **static** **void** writeFileByLine(FileChannel fcout, ByteBuffer wBuffer,  
111.             String line) \{  
112.         **try** \{  
113.             fcout.write(wBuffer.wrap(line.getBytes("UTF-8")), fcout.size());  
114.   
115.         \} **catch** (IOException e) \{  
116.             e.printStackTrace();  
117.         \}  
118.     \}  
119. \}

![save_snippets.png][]

[JAVA_NIO]: http://blog.csdn.net/v123411739/article/details/50620289
[NIO]: http://www.iteye.com/magazines/132-Java-NIO
[http_www.sharejs.com_codes_java_1334]: http://www.sharejs.com/codes/java/1334
[Center]: /images/20220720/0ccf93f7767045f7ac010142d6d418d7.png
[view plain]: http://blog.csdn.net/v123411739/article/details/50620289#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/1572254
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/1572254/fork
[save_snippets.png]: /images/20220720/f016c3482a1a4746813296366372092e.png