zoukankan      html  css  js  c++  java

  • java读写文本文件大全

    使用Java操作文本文件的方法详解
    摘要: 最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类
    最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
    length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。
    　　当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，
    它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。当使用FileReader读取文件
    的时候。
    view plain
    1. FileReader fr = new FileReader("ming.txt"); 
    2. int ch = 0; 
    3. while((ch = fr.read())!=-1 ) 
    4. { 
    5. System.out.print((char)ch); 
    6. } 

    其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用
    InputStreamReader来读取文件的时候
    while((ch = isr.read())!=-1)
    {
    System.out.print((char)ch);
    }
    这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率
    我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
    String data = null;
    while((data = br.readLine())!=null)
    {
    System.out.println(data);
    }
    当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先
    放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
    view plain
    ·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
    1. FileWriter fw = new FileWriter("hello.txt"); 
    2. String s = "hello world"; 
    3. fw.write(s,0,s.length()); 
    4. fw.flush(); 
    5. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt")); 
    6. osw.write(s,0,s.length()); 
    7. osw.flush(); 
    8. PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true); 
    9. pw.println(s); 

    不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。

    view plain
    ·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
    1. import java.io.*; 
    2. publicclass TestFile2 
    3. { 
    4. publicstaticvoid main(String[] args) throws IOException 
    5. { 
    6. FileReader fr = new FileReader("ming.txt"); 
    7. char[] buffer = newchar[1024]; 
    8. int ch = 0; 
    9. while((ch = fr.read())!=-1 ) 
    10. { 
    11. System.out.print((char)ch); 
    12. } 
    13. 　　InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt")); 
    14. while((ch = isr.read())!=-1) 
    15. { 
    16. System.out.print((char)ch); 
    17. } 
    18. 　　BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt"))); 
    19. String data = null; 
    20. while((data = br.readLine())!=null) 
    21. { 
    22. System.out.println(data); 
    23. } 
    24. 　　FileWriter fw = new FileWriter("hello.txt"); 
    25. String s = "hello world"; 
    26. fw.write(s,0,s.length()); 
    27. fw.flush(); 
    28. 　　OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt")); 
    29. osw.write(s,0,s.length()); 
    30. osw.flush(); 
    31. 　　PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true); 
    32. pw.println(s); 
    33. 　　fr.close(); 
    34. isr.close(); 
    35. br.close(); 
    36. fw.close(); 
    37. osw.close(); 
    38. pw.close(); 
    39. } 
    40. } 

    java中多种方式读文件
    一、多种方式读文件内容。
    1、按字节读取文件内容
    2、按字符读取文件内容
    3、按行读取文件内容
    4、随机读取文件内容

    view plain
    ·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
    1. import java.io.BufferedReader; 
    2. import java.io.File; 
    3. import java.io.FileInputStream; 
    4. import java.io.FileReader; 
    5. import java.io.IOException; 
    6. import java.io.InputStream; 
    7. import java.io.InputStreamReader; 
    8. import java.io.RandomAccessFile; 
    9. import java.io.Reader; 
    10. publicclass ReadFromFile { 
    11. /**
    12. * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
    13. * @param fileName 文件的名
    14. */ 
    15. publicstaticvoid readFileByBytes(String fileName){ 
    16. File file = new File(fileName); 
    17. InputStream in = null; 
    18. try { 
    19. System.out.println("以字节为单位读取文件内容，一次读一个字节："); 
    20. // 一次读一个字节 
    21. in = new FileInputStream(file); 
    22. int tempbyte; 
    23. while((tempbyte=in.read()) != -1){ 
    24. System.out.write(tempbyte); 
    25. } 
    26. in.close(); 
    27. } catch (IOException e) { 
    28. e.printStackTrace(); 
    29. return; 
    30. } 
    31. try { 
    32. System.out.println("以字节为单位读取文件内容，一次读多个字节："); 
    33. //一次读多个字节 
    34. byte[] tempbytes = newbyte[100]; 
    35. int byteread = 0; 
    36. in = new FileInputStream(fileName); 
    37. ReadFromFile.showAvailableBytes(in); 
    38. //读入多个字节到字节数组中，byteread为一次读入的字节数 
    39. while ((byteread = in.read(tempbytes)) != -1){ 
    40. System.out.write(tempbytes, 0, byteread); 
    41. } 
    42. } catch (Exception e1) { 
    43. e1.printStackTrace(); 
    44. } finally { 
    45. if (in != null){ 
    46. try { 
    47. in.close(); 
    48. } catch (IOException e1) { 
    49. } 
    50. } 
    51. } 
    52. } 
    53. /**
    54. * 以字符为单位读取文件，常用于读文本，数字等类型的文件
    55. * @param fileName 文件名
    56. */ 
    57. publicstaticvoid readFileByChars(String fileName){ 
    58. File file = new File(fileName); 
    59. Reader reader = null; 
    60. try { 
    61. System.out.println("以字符为单位读取文件内容，一次读一个字节："); 
    62. // 一次读一个字符 
    63. reader = new InputStreamReader(new FileInputStream(file)); 
    64. int tempchar; 
    65. while ((tempchar = reader.read()) != -1){ 
    66. //对于windows下，rn这两个字符在一起时，表示一个换行。 
    67. //但如果这两个字符分开显示时，会换两次行。 
    68. //因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。 
    69. if (((char)tempchar) != 'r'){ 
    70. System.out.print((char)tempchar); 
    71. } 
    72. } 
    73. reader.close(); 
    74. } catch (Exception e) { 
    75. e.printStackTrace(); 
    76. } 
    77. try { 
    78. System.out.println("以字符为单位读取文件内容，一次读多个字节："); 
    79. //一次读多个字符 
    80. char[] tempchars = newchar[30]; 
    81. int charread = 0; 
    82. reader = new InputStreamReader(new FileInputStream(fileName)); 
    83. //读入多个字符到字符数组中，charread为一次读取字符数 
    84. while ((charread = reader.read(tempchars))!=-1){ 
    85. //同样屏蔽掉r不显示 
    86. if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){ 
    87. System.out.print(tempchars); 
    88. }else{ 
    89. for (int i=0; i<charread; i++){ 
    90. if(tempchars[i] == 'r'){ 
    91. continue; 
    92. }else{ 
    93. System.out.print(tempchars[i]); 
    94. } 
    95. } 
    96. } 
    97. } 
    98. } catch (Exception e1) { 
    99. e1.printStackTrace(); 
    100. }finally { 
    101. if (reader != null){ 
    102. try { 
    103. reader.close(); 
    104. } catch (IOException e1) { 
    105. } 
    106. } 
    107. } 
    108. } 
    109. /**
    110. * 以行为单位读取文件，常用于读面向行的格式化文件
    111. * @param fileName 文件名
    112. */ 
    113. publicstaticvoid readFileByLines(String fileName){ 
    114. File file = new File(fileName); 
    115. BufferedReader reader = null; 
    116. try { 
    117. System.out.println("以行为单位读取文件内容，一次读一整行："); 
    118. reader = new BufferedReader(new FileReader(file)); 
    119. String tempString = null; 
    120. int line = 1; 
    121. //一次读入一行，直到读入null为文件结束 
    122. while ((tempString = reader.readLine()) != null){ 
    123. //显示行号 
    124. System.out.println("line " + line + ": " + tempString); 
    125. line++; 
    126. } 
    127. reader.close(); 
    128. } catch (IOException e) { 
    129. e.printStackTrace(); 
    130. } finally { 
    131. if (reader != null){ 
    132. try { 
    133. reader.close(); 
    134. } catch (IOException e1) { 
    135. } 
    136. } 
    137. } 
    138. } 
    139. /**
    140. * 随机读取文件内容
    141. * @param fileName 文件名
    142. */ 
    143. publicstaticvoid readFileByRandomAccess(String fileName){ 
    144. RandomAccessFile randomFile = null; 
    145. try { 
    146. System.out.println("随机读取一段文件内容："); 
    147. // 打开一个随机访问文件流，按只读方式 
    148. randomFile = new RandomAccessFile(fileName, "r"); 
    149. // 文件长度，字节数 
    150. long fileLength = randomFile.length(); 
    151. // 读文件的起始位置 
    152. int beginIndex = (fileLength > 4) ? 4 : 0; 
    153. //将读文件的开始位置移到beginIndex位置。 
    154. randomFile.seek(beginIndex); 
    155. byte[] bytes = newbyte[10]; 
    156. int byteread = 0; 
    157. //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。 
    158. //将一次读取的字节数赋给byteread 
    159. while ((byteread = randomFile.read(bytes)) != -1){ 
    160. System.out.write(bytes, 0, byteread); 
    161. } 
    162. } catch (IOException e){ 
    163. e.printStackTrace(); 
    164. } finally { 
    165. if (randomFile != null){ 
    166. try { 
    167. randomFile.close(); 
    168. } catch (IOException e1) { 
    169. } 
    170. } 
    171. } 
    172. } 
    173. /**
    174. * 显示输入流中还剩的字节数
    175. * @param in
    176. */ 
    177. privatestaticvoid showAvailableBytes(InputStream in){ 
    178. try { 
    179. System.out.println("当前字节输入流中的字节数为:" + in.available()); 
    180. } catch (IOException e) { 
    181. e.printStackTrace(); 
    182. } 
    183. } 
    184. publicstaticvoid main(String[] args) { 
    185. String fileName = "C:/temp/newTemp.txt"; 
    186. ReadFromFile.readFileByBytes(fileName); 
    187. ReadFromFile.readFileByChars(fileName); 
    188. ReadFromFile.readFileByLines(fileName); 
    189. ReadFromFile.readFileByRandomAccess(fileName); 
    190. } 
    191. } 
    192. 二、将内容追加到文件尾部 
    193. import java.io.FileWriter; 
    194. import java.io.IOException; 
    195. import java.io.RandomAccessFile; 
    196. /**
    197. * 将内容追加到文件尾部
    198. */ 
    199. publicclass AppendToFile { 
    200. /**
    201. * A方法追加文件：使用RandomAccessFile
    202. * @param fileName 文件名
    203. * @param content 追加的内容
    204. */ 
    205. publicstaticvoid appendMethodA(String fileName, 
    206.  
    207. String content){ 
    208. try { 
    209. // 打开一个随机访问文件流，按读写方式 
    210. RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw"); 
    211. // 文件长度，字节数 
    212. long fileLength = randomFile.length(); 
    213. //将写文件指针移到文件尾。 
    214. randomFile.seek(fileLength); 
    215. randomFile.writeBytes(content); 
    216. randomFile.close(); 
    217. } catch (IOException e){ 
    218. e.printStackTrace(); 
    219. } 
    220. } 
    221. /**
    222. * B方法追加文件：使用FileWriter
    223. * @param fileName
    224. * @param content
    225. */ 
    226. publicstaticvoid appendMethodB(String fileName, String content){ 
    227. try { 
    228. //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件 
    229. FileWriter writer = new FileWriter(fileName, true); 
    230. writer.write(content); 
    231. writer.close(); 
    232. } catch (IOException e) { 
    233. e.printStackTrace(); 
    234. } 
    235. } 
    236. publicstaticvoid main(String[] args) { 
    237. String fileName = "C:/temp/newTemp.txt"; 
    238. String content = "new append!"; 
    239. //按方法A追加文件 
    240. AppendToFile.appendMethodA(fileName, content); 
    241. AppendToFile.appendMethodA(fileName, "append end. n"); 
    242. //显示文件内容 
    243. ReadFromFile.readFileByLines(fileName); 
    244. //按方法B追加文件 
    245. AppendToFile.appendMethodB(fileName, content); 
    246. AppendToFile.appendMethodB(fileName, "append end. n"); 
    247. //显示文件内容 
    248. ReadFromFile.readFileByLines(fileName); 
    249. } 
    250. } 
  • 相关阅读:
    浪潮之巅阅读笔记
    人月神话阅读笔记3
    学习报告
    人月神话阅读笔记2
    学习报告
    第十一周学习总结
    软件杯项目——手写体识别
    第十周学习进度
    第九周学习进度
    《软件架构师的12项修炼》阅读笔记
  • 原文地址：https://www.cnblogs.com/peizhe123/p/4068660.html
Copyright © 2011-2022 走看看