java读取文件内容的方法总结

java读取文件内容的方法总结

标签： java

2017-06-18 23:01 2人阅读 评论(0) 收藏 编辑 删除

本文章已收录于：

经常用到Java读取文件，做了个总结，分以下几种：

       1，以字节为单位读取文件；

       2，以字符为单位读取文件；

       3，以行为单位读取文件；

       4，随机读取文件内容；

完整代码如下：

[java] view plain copy

print ?

1. package com.test;  
2. import java.io.BufferedReader;  
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileReader;  
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.   
12. public class ReadFromFile {  
13.     /** 
14.      * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。 
15.      */  
16.     public static void readFileByBytes(String fileName) {  
17.         File file = new File(fileName);  
18.         InputStream in = null;  
19.         try {  
20.             System.out.println("以字节为单位读取文件内容，一次读一个字节：");  
21.             // 一次读一个字节  
22.             in = new FileInputStream(file);  
23.             int tempbyte;  
24.             while ((tempbyte = in.read()) != -1) {  
25.                 System.out.write(tempbyte);  
26.             }  
27.             in.close();  
28.         } catch (IOException e) {  
29.             e.printStackTrace();  
30.             return;  
31.         }  
32.         try {  
33.             System.out.println("以字节为单位读取文件内容，一次读多个字节：");  
34.             // 一次读多个字节  
35.             byte[] tempbytes = new byte[100];  
36.             int byteread = 0;  
37.             in = new FileInputStream(fileName);  
38.             ReadFromFile.showAvailableBytes(in);  
39.             // 读入多个字节到字节数组中，byteread为一次读入的字节数  
40.             while ((byteread = in.read(tempbytes)) != -1) {  
41.                 System.out.write(tempbytes, 0, byteread);  
42.             }  
43.         } catch (Exception e1) {  
44.             e1.printStackTrace();  
45.         } finally {  
46.             if (in != null) {  
47.                 try {  
48.                     in.close();  
49.                 } catch (IOException e1) {  
50.                 }  
51.             }  
52.         }  
53.     }  
54.   
55.     /** 
56.      * 以字符为单位读取文件，常用于读文本，数字等类型的文件 
57.      */  
58.     public static void readFileByChars(String fileName) {  
59.         File file = new File(fileName);  
60.         Reader reader = null;  
61.         try {  
62.             System.out.println("以字符为单位读取文件内容，一次读一个字节：");  
63.             // 一次读一个字符  
64.             reader = new InputStreamReader(new FileInputStream(file));  
65.             int tempchar;  
66.             while ((tempchar = reader.read()) != -1) {  
67.                 // 对于windows下，\r\n这两个字符在一起时，表示一个换行。  
68.                 // 但如果这两个字符分开显示时，会换两次行。  
69.                 // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。  
70.                 if (((char) tempchar) != '\r') {  
71.                     System.out.print((char) tempchar);  
72.                 }  
73.             }  
74.             reader.close();  
75.         } catch (Exception e) {  
76.             e.printStackTrace();  
77.         }  
78.         try {  
79.             System.out.println("以字符为单位读取文件内容，一次读多个字节：");  
80.             // 一次读多个字符  
81.             char[] tempchars = new char[30];  
82.             int charread = 0;  
83.             reader = new InputStreamReader(new FileInputStream(fileName));  
84.             // 读入多个字符到字符数组中，charread为一次读取字符数  
85.             while ((charread = reader.read(tempchars)) != -1) {  
86.                 // 同样屏蔽掉\r不显示  
87.                 if ((charread == tempchars.length)  
88.                         && (tempchars[tempchars.length - 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 (Exception e1) {  
102.             e1.printStackTrace();  
103.         } finally {  
104.             if (reader != null) {  
105.                 try {  
106.                     reader.close();  
107.                 } catch (IOException e1) {  
108.                 }  
109.             }  
110.         }  
111.     }  
112.   
113.     /** 
114.      * 以行为单位读取文件，常用于读面向行的格式化文件 
115.      */  
116.     public static void readFileByLines(String fileName) {  
117.         File file = new File(fileName);  
118.         BufferedReader reader = null;  
119.         try {  
120.             System.out.println("以行为单位读取文件内容，一次读一整行：");  
121.             reader = new BufferedReader(new FileReader(file));  
122.             String tempString = null;  
123.             int line = 1;  
124.             // 一次读入一行，直到读入null为文件结束  
125.             while ((tempString = reader.readLine()) != null) {  
126.                 // 显示行号  
127.                 System.out.println("line " + line + ": " + tempString);  
128.                 line++;  
129.             }  
130.             reader.close();  
131.         } catch (IOException e) {  
132.             e.printStackTrace();  
133.         } finally {  
134.             if (reader != null) {  
135.                 try {  
136.                     reader.close();  
137.                 } catch (IOException e1) {  
138.                 }  
139.             }  
140.         }  
141.     }  
142.   
143.     /** 
144.      * 随机读取文件内容 
145.      */  
146.     public static void readFileByRandomAccess(String fileName) {  
147.         RandomAccessFile randomFile = null;  
148.         try {  
149.             System.out.println("随机读取一段文件内容：");  
150.             // 打开一个随机访问文件流，按只读方式  
151.             randomFile = new RandomAccessFile(fileName, "r");  
152.             // 文件长度，字节数  
153.             long fileLength = randomFile.length();  
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.                 System.out.write(bytes, 0, byteread);  
164.             }  
165.         } catch (IOException e) {  
166.             e.printStackTrace();  
167.         } finally {  
168.             if (randomFile != null) {  
169.                 try {  
170.                     randomFile.close();  
171.                 } catch (IOException e1) {  
172.                 }  
173.             }  
174.         }  
175.     }  
176.   
177.     /** 
178.      * 显示输入流中还剩的字节数 
179.      */  
180.     private static void showAvailableBytes(InputStream in) {  
181.         try {  
182.             System.out.println("当前字节输入流中的字节数为:" + in.available());  
183.         } catch (IOException e) {  
184.             e.printStackTrace();  
185.         }  
186.     }  
187.   
188.     public static void main(String[] args) {  
189.         String fileName = "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 com.test;  
2. import java.io.BufferedReader;  
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileReader;  
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.   
12. public class ReadFromFile {  
13.     /** 
14.      * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。 
15.      */  
16.     public static void readFileByBytes(String fileName) {  
17.         File file = new File(fileName);  
18.         InputStream in = null;  
19.         try {  
20.             System.out.println("以字节为单位读取文件内容，一次读一个字节：");  
21.             // 一次读一个字节  
22.             in = new FileInputStream(file);  
23.             int tempbyte;  
24.             while ((tempbyte = in.read()) != -1) {  
25.                 System.out.write(tempbyte);  
26.             }  
27.             in.close();  
28.         } catch (IOException e) {  
29.             e.printStackTrace();  
30.             return;  
31.         }  
32.         try {  
33.             System.out.println("以字节为单位读取文件内容，一次读多个字节：");  
34.             // 一次读多个字节  
35.             byte[] tempbytes = new byte[100];  
36.             int byteread = 0;  
37.             in = new FileInputStream(fileName);  
38.             ReadFromFile.showAvailableBytes(in);  
39.             // 读入多个字节到字节数组中，byteread为一次读入的字节数  
40.             while ((byteread = in.read(tempbytes)) != -1) {  
41.                 System.out.write(tempbytes, 0, byteread);  
42.             }  
43.         } catch (Exception e1) {  
44.             e1.printStackTrace();  
45.         } finally {  
46.             if (in != null) {  
47.                 try {  
48.                     in.close();  
49.                 } catch (IOException e1) {  
50.                 }  
51.             }  
52.         }  
53.     }  
54.   
55.     /** 
56.      * 以字符为单位读取文件，常用于读文本，数字等类型的文件 
57.      */  
58.     public static void readFileByChars(String fileName) {  
59.         File file = new File(fileName);  
60.         Reader reader = null;  
61.         try {  
62.             System.out.println("以字符为单位读取文件内容，一次读一个字节：");  
63.             // 一次读一个字符  
64.             reader = new InputStreamReader(new FileInputStream(file));  
65.             int tempchar;  
66.             while ((tempchar = reader.read()) != -1) {  
67.                 // 对于windows下，\r\n这两个字符在一起时，表示一个换行。  
68.                 // 但如果这两个字符分开显示时，会换两次行。  
69.                 // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。  
70.                 if (((char) tempchar) != '\r') {  
71.                     System.out.print((char) tempchar);  
72.                 }  
73.             }  
74.             reader.close();  
75.         } catch (Exception e) {  
76.             e.printStackTrace();  
77.         }  
78.         try {  
79.             System.out.println("以字符为单位读取文件内容，一次读多个字节：");  
80.             // 一次读多个字符  
81.             char[] tempchars = new char[30];  
82.             int charread = 0;  
83.             reader = new InputStreamReader(new FileInputStream(fileName));  
84.             // 读入多个字符到字符数组中，charread为一次读取字符数  
85.             while ((charread = reader.read(tempchars)) != -1) {  
86.                 // 同样屏蔽掉\r不显示  
87.                 if ((charread == tempchars.length)  
88.                         && (tempchars[tempchars.length - 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 (Exception e1) {  
102.             e1.printStackTrace();  
103.         } finally {  
104.             if (reader != null) {  
105.                 try {  
106.                     reader.close();  
107.                 } catch (IOException e1) {  
108.                 }  
109.             }  
110.         }  
111.     }  
112.   
113.     /** 
114.      * 以行为单位读取文件，常用于读面向行的格式化文件 
115.      */  
116.     public static void readFileByLines(String fileName) {  
117.         File file = new File(fileName);  
118.         BufferedReader reader = null;  
119.         try {  
120.             System.out.println("以行为单位读取文件内容，一次读一整行：");  
121.             reader = new BufferedReader(new FileReader(file));  
122.             String tempString = null;  
123.             int line = 1;  
124.             // 一次读入一行，直到读入null为文件结束  
125.             while ((tempString = reader.readLine()) != null) {  
126.                 // 显示行号  
127.                 System.out.println("line " + line + ": " + tempString);  
128.                 line++;  
129.             }  
130.             reader.close();  
131.         } catch (IOException e) {  
132.             e.printStackTrace();  
133.         } finally {  
134.             if (reader != null) {  
135.                 try {  
136.                     reader.close();  
137.                 } catch (IOException e1) {  
138.                 }  
139.             }  
140.         }  
141.     }  
142.   
143.     /** 
144.      * 随机读取文件内容 
145.      */  
146.     public static void readFileByRandomAccess(String fileName) {  
147.         RandomAccessFile randomFile = null;  
148.         try {  
149.             System.out.println("随机读取一段文件内容：");  
150.             // 打开一个随机访问文件流，按只读方式  
151.             randomFile = new RandomAccessFile(fileName, "r");  
152.             // 文件长度，字节数  
153.             long fileLength = randomFile.length();  
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.                 System.out.write(bytes, 0, byteread);  
164.             }  
165.         } catch (IOException e) {  
166.             e.printStackTrace();  
167.         } finally {  
168.             if (randomFile != null) {  
169.                 try {  
170.                     randomFile.close();  
171.                 } catch (IOException e1) {  
172.                 }  
173.             }  
174.         }  
175.     }  
176.   
177.     /** 
178.      * 显示输入流中还剩的字节数 
179.      */  
180.     private static void showAvailableBytes(InputStream in) {  
181.         try {  
182.             System.out.println("当前字节输入流中的字节数为:" + in.available());  
183.         } catch (IOException e) {  
184.             e.printStackTrace();  
185.         }  
186.     }  
187.   
188.     public static void main(String[] args) {  
189.         String fileName = "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);
	}
}

顶

0

踩

0

 

 

• 上一篇java 异常处理总结
• 下一篇java基础语法

  相关文章推荐

• • Java读取文件内容的几种方式集合
• • Java读取TXT文件内容的方法
• • [Java]读取文件方法大全 1、按字节读取文件内容
• • 五种方式让你在java中读取properties文件内容不再是难题
• • Java读取文件内容并转换为字符串

• • Java追加文件内容的三种方法
• • felayman-----php_读取文件内容的三种方法
• • java读取文件内容的方法总结
• • java比较文件内容是否相同的方法
• • java 7 nio逐行读取文件内容