Java读写文件笔记


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

相关内容