Chinaunix首页 | 论坛 | 博客

大宝自习室whuhbj.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

hbj_2008

  • 博客访问： 293298
  • 博文数量： 69
  • 博客积分： 2946
  • 博客等级： 少校
  • 技术积分： 800
  • 用 户 组： 普通用户
  • 注册时间： 2010-04-09 04:15
文章分类

全部博文（69）

文章存档

2013年（6）

2012年（16）

2011年（18）

2010年（29）

我的朋友
最近访客
推荐博文
相关博文
使用Java操作文本文件的方法详解

分类： Java

2012-01-11 10:23:57

摘要: 最初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. }
其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用InputStreamReader来读取文件的时候:
  1. while((ch = isr.read())!=-1)
  2. {
  3.      System.out.print((char)ch);
  4. }
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较耗费时间的，如果为了提高效率，我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。
  1. BufferedReader br = new BufferedReader(
  2.                         new InputStreamReader(
  3.                             new FileInputStream("ming.txt")));
  4. String data = null;
  5. while((data = br.readLine())!=null)
  6. {
  7.      System.out.println(data);
  8. }
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
  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(
  9.                      new OutputStreamWriter(
  10.                          new FileOutputStream("hello3.txt")),true);
  11. pw.println(s);
不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。
  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(
  19.                                 new InputStreamReader(
  20.                                      new FileInputStream("ming.txt")));
  21.         String data = null;
  22.         while((data = br.readLine())!=null)
  23.         {
  24.             System.out.println(data);
  25.         }
  26.     　　 FileWriter fw = new FileWriter("hello.txt");
  27.         String s = "hello world";
  28.         fw.write(s,0,s.length());
  29.         fw.flush();
  30.     　　OutputStreamWriter osw = new OutputStreamWriter(
  31.                                      new FileOutputStream("hello2.txt"));
  32.         osw.write(s,0,s.length());
  33.         osw.flush();
  34.     　　PrintWriter pw = new PrintWriter(
  35.                              new OutputStreamWriter(
  36.                                  new FileOutputStream("hello3.txt")),true);
  37.         pw.println(s);
  38.     　　fr.close();
  39.         isr.close();
  40.         br.close();
  41.         fw.close();
  42.         osw.close();
  43.         pw.close();
  44.     }
  45. }
java中多种方式读文件
(一) 多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
  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.     
  186.         String fileName = "C:/temp/newTemp.txt";
  187.         ReadFromFile.readFileByBytes(fileName);
  188.         ReadFromFile.readFileByChars(fileName);
  189.         ReadFromFile.readFileByLines(fileName);
  190.         ReadFromFile.readFileByRandomAccess(fileName);
  191.     }
  192. }
  (二) 将内容追加到文件尾部 
  1. import java.io.FileWriter;
  2. import java.io.IOException;
  3. import java.io.RandomAccessFile;
  4. /**
  5. * 将内容追加到文件尾部
  6. */
  7. public class AppendToFile {
  8. /**
  9. * A方法追加文件：使用RandomAccessFile
  10. * @param fileName 文件名
  11. * @param content 追加的内容
  12. */
  13.     public static void appendMethodA(String fileName, String content){
  14.         try {
  15.         // 打开一个随机访问文件流，按读写方式
  16.         RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
  17.         // 文件长度，字节数
  18.         long fileLength = randomFile.length();
  19.         //将写文件指针移到文件尾。
  20.         randomFile.seek(fileLength);
  21.         randomFile.writeBytes(content);
  22.         randomFile.close();
  23.         } catch (IOException e){
  24.             e.printStackTrace();
  25.         }
  26.     }
  27.     /**
  28.     * B方法追加文件：使用FileWriter
  29.     * @param fileName
  30.     * @param content
  31.     */
  32.     public static void appendMethodB(String fileName, String content){
  33.         try {
  34.             //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
  35.             FileWriter writer = new FileWriter(fileName, true);
  36.             writer.write(content);
  37.             writer.close();
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  42.     public static void main(String[] args) {
  43.         String fileName = "C:/temp/newTemp.txt";
  44.         String content = "new append!";
  45.         //按方法A追加文件
  46.         AppendToFile.appendMethodA(fileName, content);
  47.         AppendToFile.appendMethodA(fileName, "append end. n");
  48.         //显示文件内容
  49.         ReadFromFile.readFileByLines(fileName);
  50.         //按方法B追加文件
  51.         AppendToFile.appendMethodB(fileName, content);
  52.         AppendToFile.appendMethodB(fileName, "append end. n");
  53.         //显示文件内容
  54.         ReadFromFile.readFileByLines(fileName);
  55.     }
  56. }
转自： http://blog.csdn.net/smartcat86/article/details/4085739
阅读(1174) | 评论(0) | 转发(2) |
0

上一篇：你必须非常努力，才能看起来毫不费力

下一篇：给程序员新手的一些建议

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6