java读取文件方法大全

一、多种方式读文件内容。

1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容

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.IOException;  

6.    import java.io.InputStream;  

7.    import java.io.InputStreamReader;  

8.    import java.io.RandomAccessFile;  

9.    import java.io.Reader;  

10.   

11. public class ReadFromFile {  

12.     /** 

13.      * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。 

14.      *  

15.      * @paramfileName 

16.      *           文件的名 

17.      */  

18.     public static void readFileByBytes(StringfileName) {  

19.         Filefile = new File(fileName);  

20.         InputStreamin = null;  

21.         try {  

22.             System.out.println("以字节为单位读取文件内容，一次读一个字节：");  

23.             //一次读一个字节  

24.             in= new FileInputStream(file);  

25.             int tempbyte;  

26.             while ((tempbyte= in.read()) != -1) {  

27.                 System.out.write(tempbyte);  

28.             }  

29.             in.close();  

30.         } catch (IOExceptione) {  

31.             e.printStackTrace();  

32.             return;  

33.         }  

34.         try {  

35.             System.out.println("以字节为单位读取文件内容，一次读多个字节：");  

36.             //一次读多个字节  

37.             byte[]tempbytes = new byte[100];  

38.             int byteread= 0;  

39.             in= new FileInputStream(fileName);  

40.             ReadFromFile.showAvailableBytes(in);  

41.             //读入多个字节到字节数组中，byteread为一次读入的字节数  

42.             while ((byteread= in.read(tempbytes)) != -1) {  

43.                 System.out.write(tempbytes, 0,byteread);  

44.             }  

45.         } catch (Exceptione1) {  

46.             e1.printStackTrace();  

47.         } finally {  

48.             if (in!= null) {  

49.                 try {  

50.                     in.close();  

51.                 } catch (IOExceptione1) {  

52.                 }  

53.             }  

54.         }  

55.     }  

56.   

57.     /** 

58.      * 以字符为单位读取文件，常用于读文本，数字等类型的文件 

59.      *  

60.      * @paramfileName 

61.      *           文件名 

62.      */  

63.     public static void readFileByChars(StringfileName) {  

64.         Filefile = new File(fileName);  

65.         Readerreader = null;  

66.         try {  

67.             System.out.println("以字符为单位读取文件内容，一次读一个字节：");  

68.             //一次读一个字符  

69.             reader= new InputStreamReader(new FileInputStream(file));  

70.             int tempchar;  

71.             while ((tempchar= reader.read()) != -1) {  

72.                 //对于windows下，\r\n这两个字符在一起时，表示一个换行。  

73.                 //但如果这两个字符分开显示时，会换两次行。  

74.                 //因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。  

75.                 if (((char)tempchar) != '\r') {  

76.                     System.out.print((char)tempchar);  

77.                 }  

78.             }  

79.             reader.close();  

80.         } catch (Exceptione) {  

81.             e.printStackTrace();  

82.         }  

83.         try {  

84.             System.out.println("以字符为单位读取文件内容，一次读多个字节：");  

85.             //一次读多个字符  

86.             char[]tempchars = new char[30];  

87.             int charread= 0;  

88.             reader= new InputStreamReader(new FileInputStream(fileName));  

89.             //读入多个字符到字符数组中，charread为一次读取字符数  

90.             while ((charread= reader.read(tempchars)) != -1) {  

91.                 //同样屏蔽掉\r不显示  

92.                 if ((charread== tempchars.length)  

93.                         &&(tempchars[tempchars.length - 1] != '\r')) {  

94.                     System.out.print(tempchars);  

95.                 } else {  

96.                     for (int i= 0; i < charread; i++) {  

97.                         if (tempchars[i]== '\r') {  

98.                             continue;  

99.                         } else {  

100.                                          System.out.print(tempchars[i]);  

101.                                      }  

102.                                  }  

103.                              }  

104.                          }  

105.                

106.                      } catch (Exceptione1) {  

107.                          e1.printStackTrace();  

108.                      } finally {  

109.                          if (reader!= null) {  

110.                              try {  

111.                                  reader.close();  

112.                              } catch (IOExceptione1) {  

113.                              }  

114.                          }  

115.                      }  

116.                  }  

117.                

118.                  /** 

119.                   *以行为单位读取文件，常用于读面向行的格式化文件 

120.                   *  

121.                   *@param fileName 

122.                   *           文件名 

123.                   */  

124.                  public static void readFileByLines(StringfileName) {  

125.                      Filefile = new File(fileName);  

126.                      BufferedReaderreader = null;  

127.                      try {  

128.                          System.out.println("以行为单位读取文件内容，一次读一整行：");  

129.                          reader= new BufferedReader(new FileReader(file));  

130.                          StringtempString = null;  

131.                          int line= 1;  

132.                          //一次读入一行，直到读入null为文件结束  

133.                          while ((tempString= reader.readLine()) != null) {  

134.                              //显示行号  

135.                              System.out.println("line" + line + ": " + tempString);  

136.                              line++;  

137.                          }  

138.                          reader.close();  

139.                      } catch (IOExceptione) {  

140.                          e.printStackTrace();  

141.                      } finally {  

142.                          if (reader!= null) {  

143.                              try {  

144.                                  reader.close();  

145.                              } catch (IOExceptione1) {  

146.                              }  

147.                          }  

148.                      }  

149.                  }  

150.                

151.                  /** 

152.                   *随机读取文件内容 

153.                   *  

154.                   *@param fileName 

155.                   *           文件名 

156.                   */  

157.                  public static void readFileByRandomAccess(StringfileName) {  

158.                      RandomAccessFilerandomFile = null;  

159.                      try {  

160.                          System.out.println("随机读取一段文件内容：");  

161.                          //打开一个随机访问文件流，按只读方式  

162.                          randomFile= new RandomAccessFile(fileName, "r");  

163.                          //文件长度，字节数  

164.                          long fileLength= randomFile.length();  

165.                          //读文件的起始位置  

166.                          int beginIndex= (fileLength > 4) ? 4 : 0;  

167.                          //将读文件的开始位置移到beginIndex位置。  

168.                          randomFile.seek(beginIndex);  

169.                          byte[]bytes = new byte[10];  

170.                          int byteread= 0;  

171.                          //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。  

172.                          //将一次读取的字节数赋给byteread  

173.                          while ((byteread= randomFile.read(bytes)) != -1) {  

174.                              System.out.write(bytes, 0,byteread);  

175.                          }  

176.                      } catch (IOExceptione) {  

177.                          e.printStackTrace();  

178.                      } finally {  

179.                          if (randomFile!= null) {  

180.                              try {  

181.                                  randomFile.close();  

182.                              } catch (IOExceptione1) {  

183.                              }  

184.                          }  

185.                      }  

186.                  }  

187.                

188.                  /** 

189.                   *显示输入流中还剩的字节数 

190.                   *  

191.                   *@param in 

192.                   */  

193.                  private static void showAvailableBytes(InputStreamin) {  

194.                      try {  

195.                          System.out.println("当前字节输入流中的字节数为:" +in.available());  

196.                      } catch (IOExceptione) {  

197.                          e.printStackTrace();  

198.                      }  

199.                  }  

200.                

201.                  public static void main(String[]args) {  

202.                      StringfileName = "C:/temp/newTemp.txt";  

203.                      ReadFromFile.readFileByBytes(fileName);  

204.                      ReadFromFile.readFileByChars(fileName);  

205.                      ReadFromFile.readFileByLines(fileName);  

206.                      ReadFromFile.readFileByRandomAccess(fileName);  

207.                  }  

208.              }  

二、将内容追加到文件尾部

1.    import java.io.FileWriter;  

2.    import java.io.IOException;  

3.    import java.io.RandomAccessFile;  

4.      

5.    /** 

6.     * 将内容追加到文件尾部 

7.     */  

8.    public class AppendToFile {  

9.      

10.     /** 

11.      * A方法追加文件：使用RandomAccessFile 

12.      * @param fileName 文件名 

13.      * @param content 追加的内容 

14.      */  

15.     public static void appendMethodA(StringfileName, String content) {  

16.         try {  

17.             //打开一个随机访问文件流，按读写方式  

18.             RandomAccessFilerandomFile= new RandomAccessFile(fileName, "rw");  

19.             //文件长度，字节数  

20.             long fileLength= randomFile.length();  

21.             //将写文件指针移到文件尾。  

22.             randomFile.seek(fileLength);  

23.             randomFile.writeBytes(content);  

24.             randomFile.close();  

25.         } catch (IOExceptione) {  

26.             e.printStackTrace();  

27.         }  

28.     }  

29.   

30.     /** 

31.      * B方法追加文件：使用FileWriter 

32.      * @paramfileName 

33.      * @param content 

34.      */  

35.     public static void appendMethodB(StringfileName, String content) {  

36.         try {  

37.             //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件  

38.             FileWriterwriter = new FileWriter(fileName, true);  

39.             writer.write(content);  

40.             writer.close();  

41.         } catch (IOExceptione) {  

42.             e.printStackTrace();  

43.         }  

44.     }  

45.   

46.     public static void main(String[]args) {  

47.         StringfileName = "C:/temp/newTemp.txt";  

48.         Stringcontent = "new append!";  

49.         //按方法A追加文件  

50.         AppendToFile.appendMethodA(fileName,content);  

51.         AppendToFile.appendMethodA(fileName, "appendend. \n");  

52.         //显示文件内容  

53.         ReadFromFile.readFileByLines(fileName);  

54.         //按方法B追加文件  

55.         AppendToFile.appendMethodB(fileName,content);  

56.         AppendToFile.appendMethodB(fileName, "appendend. \n");  

57.         //显示文件内容  

58.         ReadFromFile.readFileByLines(fileName);  

59.     }  

60. }