注意：当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用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(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
9 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(new InputStreamReader(new FileInputStream("ming.txt")));
19 String data = null;
20 while((data = br.readLine())!=null)
21 {
22 System.out.println(data);
23 }
24 FileWriter fw = new FileWriter("hello.txt");
25 String s = "hello world";
26 fw.write(s,0,s.length());
27 fw.flush();
28 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
29 osw.write(s,0,s.length());
30 osw.flush();
31 PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
32 pw.println(s);
33 fr.close();
34 isr.close();
35 br.close();
36 fw.close();
37 osw.close();
38 pw.close();
39 }
40 }
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 String fileName = "C:/temp/newTemp.txt";
186 ReadFromFile.readFileByBytes(fileName);
187 ReadFromFile.readFileByChars(fileName);
188 ReadFromFile.readFileByLines(fileName);
189 ReadFromFile.readFileByRandomAccess(fileName);
190 }
191 }
二、将内容追加到文件尾部
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,
14
15 String content){
16 try {
17 // 打开一个随机访问文件流，按读写方式
18 RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
19 // 文件长度，字节数
20 long fileLength = randomFile.length();
21 //将写文件指针移到文件尾。
22 randomFile.seek(fileLength);
23 randomFile.writeBytes(content);
24 randomFile.close();
25 } catch (IOException e){
26 e.printStackTrace();
27 }
28 }
29 /**
30 * B方法追加文件：使用FileWriter
31 * @param fileName
32 * @param content
33 */
34 public static void appendMethodB(String fileName, String content){
35 try {
36 //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
37 FileWriter writer = new FileWriter(fileName, true);
38 writer.write(content);
39 writer.close();
40 } catch (IOException e) {
41 e.printStackTrace();
42 }
43 }
44 public static void main(String[] args) {
45 String fileName = "C:/temp/newTemp.txt";
46 String content = "new append!";
47 //按方法A追加文件
48 AppendToFile.appendMethodA(fileName, content);
49 AppendToFile.appendMethodA(fileName, "append end. n");
50 //显示文件内容
51 ReadFromFile.readFileByLines(fileName);
52 //按方法B追加文件
53 AppendToFile.appendMethodB(fileName, content);
54 AppendToFile.appendMethodB(fileName, "append end. n");
55 //显示文件内容
56 ReadFromFile.readFileByLines(fileName);
57 }
58 }