java读取文件内容的方法总结
经常用到Java读取文件，做了个总结，分以下几种：
1，以字节为单位读取文件；
2，以字符为单位读取文件；
3，以行为单位读取文件；
4，随机读取文件内容；
完整代码如下：
[java] view plain copy
print
1. package
2. import
3. import
4. import
5. import
6. import
7. import
8. import
9. import
10. import
11.
12. public class
13. /**
14. * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
15. */
16. public static void
17. new
18. null;
19. try
20. "以字节为单位读取文件内容，一次读一个字节：");
21. // 一次读一个字节
22. new
23. int
24. while ((tempbyte = in.read()) != -1) {
25. System.out.write(tempbyte);
26. }
27. in.close();
28. catch
29. e.printStackTrace();
30. return;
31. }
32. try
33. "以字节为单位读取文件内容，一次读多个字节：");
34. // 一次读多个字节
35. byte[] tempbytes = new byte[100];
36. int byteread = 0;
37. new
38. ReadFromFile.showAvailableBytes(in);
39. // 读入多个字节到字节数组中，byteread为一次读入的字节数
40. while ((byteread = in.read(tempbytes)) != -1) {
41. 0, byteread);
42. }
43. catch
44. e1.printStackTrace();
45. finally
46. if (in != null) {
47. try
48. in.close();
49. catch
50. }
51. }
52. }
53. }
54.
55. /**
56. * 以字符为单位读取文件，常用于读文本，数字等类型的文件
57. */
58. public static void
59. new
60. null;
61. try
62. "以字符为单位读取文件内容，一次读一个字节：");
63. // 一次读一个字符
64. new InputStreamReader(new
65. int
66. while ((tempchar = reader.read()) != -1) {
67. // 对于windows下，\r\n这两个字符在一起时，表示一个换行。
68. // 但如果这两个字符分开显示时，会换两次行。
69. // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
70. if (((char) tempchar) != '\r') {
71. char) tempchar);
72. }
73. }
74. reader.close();
75. catch
76. e.printStackTrace();
77. }
78. try
79. "以字符为单位读取文件内容，一次读多个字节：");
80. // 一次读多个字符
81. char[] tempchars = new char[30];
82. int charread = 0;
83. new InputStreamReader(new
84. // 读入多个字符到字符数组中，charread为一次读取字符数
85. while ((charread = reader.read(tempchars)) != -1) {
86. // 同样屏蔽掉\r不显示
87. if
88. 1] != '\r')) {
89. System.out.print(tempchars);
90. else
91. for (int i = 0; i < charread; i++) {
92. if (tempchars[i] == '\r') {
93. continue;
94. else
95. System.out.print(tempchars[i]);
96. }
97. }
98. }
99. }
100.
101. catch
102. e1.printStackTrace();
103. finally
104. if (reader != null) {
105. try
106. reader.close();
107. catch
108. }
109. }
110. }
111. }
112.
113. /**
114. * 以行为单位读取文件，常用于读面向行的格式化文件
115. */
116. public static void
117. new
118. null;
119. try
120. "以行为单位读取文件内容，一次读一整行：");
121. new BufferedReader(new
122. null;
123. int line = 1;
124. // 一次读入一行，直到读入null为文件结束
125. while ((tempString = reader.readLine()) != null) {
126. // 显示行号
127. "line " + line + ": "
128. line++;
129. }
130. reader.close();
131. catch
132. e.printStackTrace();
133. finally
134. if (reader != null) {
135. try
136. reader.close();
137. catch
138. }
139. }
140. }
141. }
142.
143. /**
144. * 随机读取文件内容
145. */
146. public static void
147. null;
148. try
149. "随机读取一段文件内容：");
150. // 打开一个随机访问文件流，按只读方式
151. new RandomAccessFile(fileName, "r");
152. // 文件长度，字节数
153. long
154. // 读文件的起始位置
155. int beginIndex = (fileLength > 4) ? 4 : 0;
156. // 将读文件的开始位置移到beginIndex位置。
157. randomFile.seek(beginIndex);
158. byte[] bytes = new byte[10];
159. int byteread = 0;
160. // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
161. // 将一次读取的字节数赋给byteread
162. while ((byteread = randomFile.read(bytes)) != -1) {
163. 0, byteread);
164. }
165. catch
166. e.printStackTrace();
167. finally
168. if (randomFile != null) {
169. try
170. randomFile.close();
171. catch
172. }
173. }
174. }
175. }
176.
177. /**
178. * 显示输入流中还剩的字节数
179. */
180. private static void
181. try
182. "当前字节输入流中的字节数为:"
183. catch
184. e.printStackTrace();
185. }
186. }
187.
188. public static void
189. "C:/temp/newTemp.txt";
190. ReadFromFile.readFileByBytes(fileName);
191. ReadFromFile.readFileByChars(fileName);
192. ReadFromFile.readFileByLines(fileName);
193. ReadFromFile.readFileByRandomAccess(fileName);
194. }
195. }[java] view plain copy
print
?
1. package
2. import
3. import
4. import
5. import
6. import
7. import
8. import
9. import
10. import
11.
12. public class
13. /**
14. * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
15. */
16. public static void
17. new
18. null;
19. try
20. "以字节为单位读取文件内容，一次读一个字节：");
21. // 一次读一个字节
22. new
23. int
24. while ((tempbyte = in.read()) != -1) {
25. System.out.write(tempbyte);
26. }
27. in.close();
28. catch
29. e.printStackTrace();
30. return;
31. }
32. try
33. "以字节为单位读取文件内容，一次读多个字节：");
34. // 一次读多个字节
35. byte[] tempbytes = new byte[100];
36. int byteread = 0;
37. new
38. ReadFromFile.showAvailableBytes(in);
39. // 读入多个字节到字节数组中，byteread为一次读入的字节数
40. while ((byteread = in.read(tempbytes)) != -1) {
41. 0, byteread);
42. }
43. catch
44. e1.printStackTrace();
45. finally
46. if (in != null) {
47. try
48. in.close();
49. catch
50. }
51. }
52. }
53. }
54.
55. /**
56. * 以字符为单位读取文件，常用于读文本，数字等类型的文件
57. */
58. public static void
59. new
60. null;
61. try
62. "以字符为单位读取文件内容，一次读一个字节：");
63. // 一次读一个字符
64. new InputStreamReader(new
65. int
66. while ((tempchar = reader.read()) != -1) {
67. // 对于windows下，\r\n这两个字符在一起时，表示一个换行。
68. // 但如果这两个字符分开显示时，会换两次行。
69. // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
70. if (((char) tempchar) != '\r') {
71. char) tempchar);
72. }
73. }
74. reader.close();
75. catch
76. e.printStackTrace();
77. }
78. try
79. "以字符为单位读取文件内容，一次读多个字节：");
80. // 一次读多个字符
81. char[] tempchars = new char[30];
82. int charread = 0;
83. new InputStreamReader(new
84. // 读入多个字符到字符数组中，charread为一次读取字符数
85. while ((charread = reader.read(tempchars)) != -1) {
86. // 同样屏蔽掉\r不显示
87. if
88. 1] != '\r')) {
89. System.out.print(tempchars);
90. else
91. for (int i = 0; i < charread; i++) {
92. if (tempchars[i] == '\r') {
93. continue;
94. else
95. System.out.print(tempchars[i]);
96. }
97. }
98. }
99. }
100.
101. catch
102. e1.printStackTrace();
103. finally
104. if (reader != null) {
105. try
106. reader.close();
107. catch
108. }
109. }
110. }
111. }
112.
113. /**
114. * 以行为单位读取文件，常用于读面向行的格式化文件
115. */
116. public static void
117. new
118. null;
119. try
120. "以行为单位读取文件内容，一次读一整行：");
121. new BufferedReader(new
122. null;
123. int line = 1;
124. // 一次读入一行，直到读入null为文件结束
125. while ((tempString = reader.readLine()) != null) {
126. // 显示行号
127. "line " + line + ": "
128. line++;
129. }
130. reader.close();
131. catch
132. e.printStackTrace();
133. finally
134. if (reader != null) {
135. try
136. reader.close();
137. catch
138. }
139. }
140. }
141. }
142.
143. /**
144. * 随机读取文件内容
145. */
146. public static void
147. null;
148. try
149. "随机读取一段文件内容：");
150. // 打开一个随机访问文件流，按只读方式
151. new RandomAccessFile(fileName, "r");
152. // 文件长度，字节数
153. long
154. // 读文件的起始位置
155. int beginIndex = (fileLength > 4) ? 4 : 0;
156. // 将读文件的开始位置移到beginIndex位置。
157. randomFile.seek(beginIndex);
158. byte[] bytes = new byte[10];
159. int byteread = 0;
160. // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
161. // 将一次读取的字节数赋给byteread
162. while ((byteread = randomFile.read(bytes)) != -1) {
163. 0, byteread);
164. }
165. catch
166. e.printStackTrace();
167. finally
168. if (randomFile != null) {
169. try
170. randomFile.close();
171. catch
172. }
173. }
174. }
175. }
176.
177. /**
178. * 显示输入流中还剩的字节数
179. */
180. private static void
181. try
182. "当前字节输入流中的字节数为:"
183. catch
184. e.printStackTrace();
185. }
186. }
187.
188. public static void
189. "C:/temp/newTemp.txt";
190. ReadFromFile.readFileByBytes(fileName);
191. ReadFromFile.readFileByChars(fileName);
192. ReadFromFile.readFileByLines(fileName);
193. ReadFromFile.readFileByRandomAccess(fileName);
194. }
195. }
package com.test;
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 {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*/
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) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
*/
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下，\r\n这两个字符在一起时，表示一个换行。
// 但如果这两个字符分开显示时，会换两次行。
// 因此，屏蔽掉\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) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*/
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) {
}
}
}
}
/**
* 随机读取文件内容
*/
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) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
*/
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);
}
}1. package
2. import
3. import
4. import
5. import
6. import
7. import
8. import
9. import
10. import
11.
12. public class
13. /**
14. * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
15. */
16. public static void
17. new
18. null;
19. try
20. "以字节为单位读取文件内容，一次读一个字节：");
21. // 一次读一个字节
22. new
23. int
24. while ((tempbyte = in.read()) != -1) {
25. System.out.write(tempbyte);
26. }
27. in.close();
28. catch
29. e.printStackTrace();
30. return;
31. }
32. try
33. "以字节为单位读取文件内容，一次读多个字节：");
34. // 一次读多个字节
35. byte[] tempbytes = new byte[100];
36. int byteread = 0;
37. new
38. ReadFromFile.showAvailableBytes(in);
39. // 读入多个字节到字节数组中，byteread为一次读入的字节数
40. while ((byteread = in.read(tempbytes)) != -1) {
41. 0, byteread);
42. }
43. catch
44. e1.printStackTrace();
45. finally
46. if (in != null) {
47. try
48. in.close();
49. catch
50. }
51. }
52. }
53. }
54.
55. /**
56. * 以字符为单位读取文件，常用于读文本，数字等类型的文件
57. */
58. public static void
59. new
60. null;
61. try
62. "以字符为单位读取文件内容，一次读一个字节：");
63. // 一次读一个字符
64. new InputStreamReader(new
65. int
66. while ((tempchar = reader.read()) != -1) {
67. // 对于windows下，\r\n这两个字符在一起时，表示一个换行。
68. // 但如果这两个字符分开显示时，会换两次行。
69. // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
70. if (((char) tempchar) != '\r') {
71. char) tempchar);
72. }
73. }
74. reader.close();
75. catch
76. e.printStackTrace();
77. }
78. try
79. "以字符为单位读取文件内容，一次读多个字节：");
80. // 一次读多个字符
81. char[] tempchars = new char[30];
82. int charread = 0;
83. new InputStreamReader(new
84. // 读入多个字符到字符数组中，charread为一次读取字符数
85. while ((charread = reader.read(tempchars)) != -1) {
86. // 同样屏蔽掉\r不显示
87. if
88. 1] != '\r')) {
89. System.out.print(tempchars);
90. else
91. for (int i = 0; i < charread; i++) {
92. if (tempchars[i] == '\r') {
93. continue;
94. else
95. System.out.print(tempchars[i]);
96. }
97. }
98. }
99. }
100.
101. catch
102. e1.printStackTrace();
103. finally
104. if (reader != null) {
105. try
106. reader.close();
107. catch
108. }
109. }
110. }
111. }
112.
113. /**
114. * 以行为单位读取文件，常用于读面向行的格式化文件
115. */
116. public static void
117. new
118. null;
119. try
120. "以行为单位读取文件内容，一次读一整行：");
121. new BufferedReader(new
122. null;
123. int line = 1;
124. // 一次读入一行，直到读入null为文件结束
125. while ((tempString = reader.readLine()) != null) {
126. // 显示行号
127. "line " + line + ": "
128. line++;
129. }
130. reader.close();
131. catch
132. e.printStackTrace();
133. finally
134. if (reader != null) {
135. try
136. reader.close();
137. catch
138. }
139. }
140. }
141. }
142.
143. /**
144. * 随机读取文件内容
145. */
146. public static void
147. null;
148. try
149. "随机读取一段文件内容：");
150. // 打开一个随机访问文件流，按只读方式
151. new RandomAccessFile(fileName, "r");
152. // 文件长度，字节数
153. long
154. // 读文件的起始位置
155. int beginIndex = (fileLength > 4) ? 4 : 0;
156. // 将读文件的开始位置移到beginIndex位置。
157. randomFile.seek(beginIndex);
158. byte[] bytes = new byte[10];
159. int byteread = 0;
160. // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
161. // 将一次读取的字节数赋给byteread
162. while ((byteread = randomFile.read(bytes)) != -1) {
163. 0, byteread);
164. }
165. catch
166. e.printStackTrace();
167. finally
168. if (randomFile != null) {
169. try
170. randomFile.close();
171. catch
172. }
173. }
174. }
175. }
176.
177. /**
178. * 显示输入流中还剩的字节数
179. */
180. private static void
181. try
182. "当前字节输入流中的字节数为:"
183. catch
184. e.printStackTrace();
185. }
186. }
187.
188. public static void
189. "C:/temp/newTemp.txt";
190. ReadFromFile.readFileByBytes(fileName);
191. ReadFromFile.readFileByChars(fileName);
192. ReadFromFile.readFileByLines(fileName);
193. ReadFromFile.readFileByRandomAccess(fileName);
194. }
195. }
package com.test;
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 {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*/
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) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
*/
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下，\r\n这两个字符在一起时，表示一个换行。
// 但如果这两个字符分开显示时，会换两次行。
// 因此，屏蔽掉\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) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*/
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) {
}
}
}
}
/**
* 随机读取文件内容
*/
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) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
*/
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);
}
}
package com.test;
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 {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*/
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) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
*/
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下，\r\n这两个字符在一起时，表示一个换行。
// 但如果这两个字符分开显示时，会换两次行。
// 因此，屏蔽掉\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) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*/
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) {
}
}
}
}
/**
* 随机读取文件内容
*/
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) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
*/
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);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
