java读写文本文件大全

长平狐 发布于 2012/11/12 11:44
阅读 377
收藏 0
使用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读取文件
的时候。
  1. FileReader fr = new FileReader("ming.txt"); 
  2. int ch = 0
  3. while((ch = fr.read())!=-1
  4. System.out.print((char)ch); 

其中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()方法。与上面对应的写文件的方法为:
·········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系统是需要我们多记记的,不然哪天就生疏了。

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

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

·········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. public class ReadFromFile { 
  11. /**
  12. * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
  13. * @param fileName 文件的名
  14. */ 
  15. public static void 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. in.close(); 
  26. } catch (IOException e) { 
  27. e.printStackTrace(); 
  28. return
  29. try
  30. System.out.println("以字节为单位读取文件内容,一次读多个字节:"); 
  31. //一次读多个字节 
  32. byte[] tempbytes = new byte[100]; 
  33. int byteread = 0
  34. in = new FileInputStream(fileName); 
  35. ReadFromFile.showAvailableBytes(in); 
  36. //读入多个字节到字节数组中,byteread为一次读入的字节数 
  37. while ((byteread = in.read(tempbytes)) != -1){ 
  38. System.out.write(tempbytes, 0, byteread); 
  39. } catch (Exception e1) { 
  40. e1.printStackTrace(); 
  41. } finally
  42. if (in != null){ 
  43. try
  44. in.close(); 
  45. } catch (IOException e1) { 
  46. /**
  47. * 以字符为单位读取文件,常用于读文本,数字等类型的文件
  48. * @param fileName 文件名
  49. */ 
  50. public static void readFileByChars(String fileName){ 
  51. File file = new File(fileName); 
  52. Reader reader = null
  53. try
  54. System.out.println("以字符为单位读取文件内容,一次读一个字节:"); 
  55. // 一次读一个字符 
  56. reader = new InputStreamReader(new FileInputStream(file)); 
  57. int tempchar; 
  58. while ((tempchar = reader.read()) != -1){ 
  59. //对于windows下,rn这两个字符在一起时,表示一个换行。 
  60. //但如果这两个字符分开显示时,会换两次行。 
  61. //因此,屏蔽掉r,或者屏蔽n。否则,将会多出很多空行。 
  62. if (((char)tempchar) != 'r'){ 
  63. System.out.print((char)tempchar); 
  64. reader.close(); 
  65. } catch (Exception e) { 
  66. e.printStackTrace(); 
  67. try
  68. System.out.println("以字符为单位读取文件内容,一次读多个字节:"); 
  69. //一次读多个字符 
  70. char[] tempchars = new char[30]; 
  71. int charread = 0
  72. reader = new InputStreamReader(new FileInputStream(fileName)); 
  73. //读入多个字符到字符数组中,charread为一次读取字符数 
  74. while ((charread = reader.read(tempchars))!=-1){ 
  75. //同样屏蔽掉r不显示 
  76. if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){ 
  77. System.out.print(tempchars); 
  78. }else
  79. for (int i=0; i<charread; i++){ 
  80. if(tempchars[i] == 'r'){ 
  81. continue
  82. }else
  83. System.out.print(tempchars[i]); 
  84. } catch (Exception e1) { 
  85. e1.printStackTrace(); 
  86. }finally
  87. if (reader != null){ 
  88. try
  89. reader.close(); 
  90. } catch (IOException e1) { 
  91. /**
  92. * 以行为单位读取文件,常用于读面向行的格式化文件
  93. * @param fileName 文件名
  94. */ 
  95. public static void readFileByLines(String fileName){ 
  96. File file = new File(fileName); 
  97. BufferedReader reader = null
  98. try
  99. System.out.println("以行为单位读取文件内容,一次读一整行:"); 
  100. reader = new BufferedReader(new FileReader(file)); 
  101. String tempString = null
  102. int line = 1
  103. //一次读入一行,直到读入null为文件结束 
  104. while ((tempString = reader.readLine()) != null){ 
  105. //显示行号 
  106. System.out.println("line " + line + ": " + tempString); 
  107. line++; 
  108. reader.close(); 
  109. } catch (IOException e) { 
  110. e.printStackTrace(); 
  111. } finally
  112. if (reader != null){ 
  113. try
  114. reader.close(); 
  115. } catch (IOException e1) { 
  116. /**
  117. * 随机读取文件内容
  118. * @param fileName 文件名
  119. */ 
  120. public static void readFileByRandomAccess(String fileName){ 
  121. RandomAccessFile randomFile = null
  122. try
  123. System.out.println("随机读取一段文件内容:"); 
  124. // 打开一个随机访问文件流,按只读方式 
  125. randomFile = new RandomAccessFile(fileName, "r"); 
  126. // 文件长度,字节数 
  127. long fileLength = randomFile.length(); 
  128. // 读文件的起始位置 
  129. int beginIndex = (fileLength > 4) ? 4 : 0
  130. //将读文件的开始位置移到beginIndex位置。 
  131. randomFile.seek(beginIndex); 
  132. byte[] bytes = new byte[10]; 
  133. int byteread = 0
  134. //一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。 
  135. //将一次读取的字节数赋给byteread 
  136. while ((byteread = randomFile.read(bytes)) != -1){ 
  137. System.out.write(bytes, 0, byteread); 
  138. } catch (IOException e){ 
  139. e.printStackTrace(); 
  140. } finally
  141. if (randomFile != null){ 
  142. try
  143. randomFile.close(); 
  144. } catch (IOException e1) { 
  145. /**
  146. * 显示输入流中还剩的字节数
  147. * @param in
  148. */ 
  149. private static void showAvailableBytes(InputStream in){ 
  150. try
  151. System.out.println("当前字节输入流中的字节数为:" + in.available()); 
  152. } catch (IOException e) { 
  153. e.printStackTrace(); 
  154. public static void main(String[] args) { 
  155. String fileName = "C:/temp/newTemp.txt"
  156. ReadFromFile.readFileByBytes(fileName); 
  157. ReadFromFile.readFileByChars(fileName); 
  158. ReadFromFile.readFileByLines(fileName); 
  159. ReadFromFile.readFileByRandomAccess(fileName); 
  160. 二、将内容追加到文件尾部 
  161. import java.io.FileWriter; 
  162. import java.io.IOException; 
  163. import java.io.RandomAccessFile; 
  164. /**
  165. * 将内容追加到文件尾部
  166. */ 
  167. public class AppendToFile { 
  168. /**
  169. * A方法追加文件:使用RandomAccessFile
  170. * @param fileName 文件名
  171. * @param content 追加的内容
  172. */ 
  173. public static void appendMethodA(String fileName, 
  174.  
  175. String content){ 
  176. try
  177. // 打开一个随机访问文件流,按读写方式 
  178. RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw"); 
  179. // 文件长度,字节数 
  180. long fileLength = randomFile.length(); 
  181. //将写文件指针移到文件尾。 
  182. randomFile.seek(fileLength); 
  183. randomFile.writeBytes(content); 
  184. randomFile.close(); 
  185. } catch (IOException e){ 
  186. e.printStackTrace(); 
  187. /**
  188. * B方法追加文件:使用FileWriter
  189. * @param fileName
  190. * @param content
  191. */ 
  192. public static void appendMethodB(String fileName, String content){ 
  193. try
  194. //打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件 
  195. FileWriter writer = new FileWriter(fileName, true); 
  196. writer.write(content); 
  197. writer.close(); 
  198. } catch (IOException e) { 
  199. e.printStackTrace(); 
  200. public static void main(String[] args) { 
  201. String fileName = "C:/temp/newTemp.txt"
  202. String content = "new append!"
  203. //按方法A追加文件 
  204. AppendToFile.appendMethodA(fileName, content); 
  205. AppendToFile.appendMethodA(fileName, "append end. n"); 
  206. //显示文件内容 
  207. ReadFromFile.readFileByLines(fileName); 
  208. //按方法B追加文件 
  209. AppendToFile.appendMethodB(fileName, content); 
  210. AppendToFile.appendMethodB(fileName, "append end. n"); 
  211. //显示文件内容 
  212. ReadFromFile.readFileByLines(fileName); 

原文链接:http://blog.csdn.net/csh624366188/article/details/6785817
加载中
返回顶部
顶部