现在的位置: 首页 > 综合 > 正文

[RE]java读写文件

2017年12月18日 ⁄ 综合 ⁄ 共 15404字 ⁄ 字号 评论关闭

source:http://guoyang1982.blog.163.com/blog/static/6148835120100811158882/

other src:http://www.doc88.com/p-80954780625.html

java读写文件大全  

2010-01-08 11:15:08|  分类:技术
|  标签:
|字号 订阅

使用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. {   
  5. System.out.print((char)ch);   
  6. }  

FileReader fr = new FileReader("ming.txt"); int ch = 0; while((ch = fr.read())!=-1 ) { 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);  

FileWriter fw = new FileWriter("hello.txt"); String s = "hello world"; fw.write(s,0,s.length()); fw.flush(); OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt")); osw.write(s,0,s.length()); osw.flush(); PrintWriter pw = new PrintWriter(new
OutputStreamWriter(new FileOutputStream("hello3.txt")),true); 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. {   
  4. public static void main(String[] args) throws IOException
      
  5. {   
  6. FileReader fr = new FileReader("ming.txt");   
  7. char[] buffer = new char[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. }  

import java.io.*; public class TestFile2 { public static void main(String[] args) throws IOException { FileReader fr = new FileReader("ming.txt"); char[] buffer = new char[1024]; int ch = 0; while((ch = fr.read())!=-1 ) { System.out.print((char)ch); }
  InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt")); while((ch = isr.read())!=-1) { System.out.print((char)ch); }   BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt"))); String data
= null; while((data = br.readLine())!=null) { System.out.println(data); }   FileWriter fw = new FileWriter("hello.txt"); String s = "hello world"; fw.write(s,0,s.length()); fw.flush();   OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length()); osw.flush();   PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true); pw.println(s);   fr.close(); isr.close(); br.close(); fw.close(); osw.close(); 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. }   
  26. in.close();   
  27. catch (IOException e) {   
  28. e.printStackTrace();   
  29. return;   
  30. }   
  31. try {   
  32. System.out.println("以字节为单位读取文件内容,一次读多个字节:");   
  33. //一次读多个字节   
  34. byte[] tempbytes = new byte[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. public static void 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 = new char[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. public static void 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. public static void 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 = new byte[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. private static void showAvailableBytes(InputStream in){
      
  178. try {   
  179. System.out.println("当前字节输入流中的字节数为:" + in.available());   
  180. catch (IOException e) {   
  181. e.printStackTrace();   
  182. }   
  183. }   
  184. public static void 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. public class AppendToFile {   
  200. /**  
  201. * A方法追加文件:使用RandomAccessFile  
  202. * @param fileName 文件名  
  203. * @param content 追加的内容  
  204. */  
  205. public static void 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. public static void 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. public static void 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. }  

import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.RandomAccessFile;
import java.io.Reader; public class ReadFromFile { /** * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。 * @param fileName 文件的名 */ public static void readFileByBytes(String fileName){ File file = new File(fileName); InputStream in = null; try { System.out.println("以字节为单位读取文件内容,一次读一个字节:");
// 一次读一个字节 in = new FileInputStream(file); int tempbyte; while((tempbyte=in.read()) != -1){ System.out.write(tempbyte); } in.close(); } catch (IOException e) { e.printStackTrace(); return; } try { System.out.println("以字节为单位读取文件内容,一次读多个字节:"); //一次读多个字节 byte[]
tempbytes = new byte[100]; int byteread = 0; in = new FileInputStream(fileName); ReadFromFile.showAvailableBytes(in); //读入多个字节到字节数组中,byteread为一次读入的字节数 while ((byteread = in.read(tempbytes)) != -1){ System.out.write(tempbytes, 0, byteread); } } catch (Exception
e1) { e1.printStackTrace(); } finally { if (in != null){ try { in.close(); } catch (IOException e1) { } } } } /** * 以字符为单位读取文件,常用于读文本,数字等类型的文件 * @param fileName 文件名 */ public static void readFileByChars(String fileName){ File file = new File(fileName); Reader
reader = null; try { System.out.println("以字符为单位读取文件内容,一次读一个字节:"); // 一次读一个字符 reader = new InputStreamReader(new FileInputStream(file)); int tempchar; while ((tempchar = reader.read()) != -1){ //对于windows下,rn这两个字符在一起时,表示一个换行。 //但如果这两个字符分开显示时,会换两次行。 //因此,屏蔽掉r,或者屏蔽n。否则,将会多出很多空行。
if (((char)tempchar) != 'r'){ System.out.print((char)tempchar); } } reader.close(); } catch (Exception e) { e.printStackTrace(); } try { System.out.println("以字符为单位读取文件内容,一次读多个字节:"); //一次读多个字符 char[] tempchars = new char[30]; int charread = 0; reader = new
InputStreamReader(new FileInputStream(fileName)); //读入多个字符到字符数组中,charread为一次读取字符数 while ((charread = reader.read(tempchars))!=-1){ //同样屏蔽掉r不显示 if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){ System.out.print(tempchars); }else{
for (int i=0; i<charread; i++){ if(tempchars[i] == 'r'){ continue; }else{ System.out.print(tempchars[i]); } } } } } catch (Exception e1) { e1.printStackTrace(); }finally { if (reader != null){ try { reader.close(); } catch (IOException e1) { } } } } /** *
以行为单位读取文件,常用于读面向行的格式化文件 * @param fileName 文件名 */ public static void readFileByLines(String fileName){ File file = new File(fileName); BufferedReader reader = null; try { System.out.println("以行为单位读取文件内容,一次读一整行:"); reader = new BufferedReader(new FileReader(file));
String tempString = null; int line = 1; //一次读入一行,直到读入null为文件结束 while ((tempString = reader.readLine()) != null){ //显示行号 System.out.println("line " + line + ": " + tempString); line++; } reader.close(); } catch (IOException e) { e.printStackTrace(); } finally
{ if (reader != null){ try { reader.close(); } catch (IOException e1) { } } } } /** * 随机读取文件内容 * @param fileName 文件名 */ public static void readFileByRandomAccess(String fileName){ RandomAccessFile randomFile = null; try { System.out.println("随机读取一段文件内容:");
// 打开一个随机访问文件流,按只读方式 randomFile = new RandomAccessFile(fileName, "r"); // 文件长度,字节数 long fileLength = randomFile.length(); // 读文件的起始位置 int beginIndex = (fileLength > 4) ? 4 : 0; //将读文件的开始位置移到beginIndex位置。 randomFile.seek(beginIndex); byte[] bytes = new byte[10];
int byteread = 0; //一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。 //将一次读取的字节数赋给byteread while ((byteread = randomFile.read(bytes)) != -1){ System.out.write(bytes, 0, byteread); } } catch (IOException e){ e.printStackTrace(); } finally { if (randomFile != null){ try { randomFile.close();
} catch (IOException e1) { } } } } /** * 显示输入流中还剩的字节数 * @param in */ private static void showAvailableBytes(InputStream in){ try { System.out.println("当前字节输入流中的字节数为:" + in.available()); } catch (IOException e) { e.printStackTrace(); } } public static void
main(String[] args) { String fileName = "C:/temp/newTemp.txt"; ReadFromFile.readFileByBytes(fileName); ReadFromFile.readFileByChars(fileName); ReadFromFile.readFileByLines(fileName); ReadFromFile.readFileByRandomAccess(fileName); } } 二、将内容追加到文件尾部 import
java.io.FileWriter; import java.io.IOException; import java.io.RandomAccessFile; /** * 将内容追加到文件尾部 */ public class AppendToFile { /** * A方法追加文件:使用RandomAccessFile * @param fileName 文件名 * @param content 追加的内容 */ public static void appendMethodA(String
fileName, String content){ try { // 打开一个随机访问文件流,按读写方式 RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw"); // 文件长度,字节数 long fileLength = randomFile.length(); //将写文件指针移到文件尾。 randomFile.seek(fileLength); randomFile.writeBytes(content); randomFile.close();
} catch (IOException e){ e.printStackTrace(); } } /** * B方法追加文件:使用FileWriter * @param fileName * @param content */ public static void appendMethodB(String fileName, String content){ try { //打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件 FileWriter writer = new FileWriter(fileName,
true); writer.write(content); writer.close(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { String fileName = "C:/temp/newTemp.txt"; String content = "new append!"; //按方法A追加文件 AppendToFile.appendMethodA(fileName,
content); AppendToFile.appendMethodA(fileName, "append end. n"); //显示文件内容 ReadFromFile.readFileByLines(fileName); //按方法B追加文件 AppendToFile.appendMethodB(fileName, content); AppendToFile.appendMethodB(fileName, "append end. n"); //显示文件内容 ReadFromFile.readFileByLines(fileName);
} }

抱歉!评论已关闭.