Java的文件IO操作：

有两种形式：字节流和字符流，字节流传输的是字节，返回的也是字节，而字符流传输的是字符，返回的也是字符。字节流可以处理任何数据，如音视频数据，而字符流仅能处理字符数据，如文本数据。

字符流操作

写字符到文件的例子:

1. import java.io.File; 
2. import java.io.FileWriter; 
3.  
4. public class FileWriteDemo { 
5.  
6.     /** 
7.      * 文件写操作 
8.      */ 
9.     public static void main(String[] args) throws Exception { 
10.         // TODO Auto-generated method stub 
11.         //1.使用File对象指定一个文件 
12.         File f = new File("c:" + File.separator + "test.txt"); 
13.         //2.使用FileWriter对象实例化，并链接到指定文件 
14.         FileWriter fwr = new FileWriter(f, true); 
15.         //3.写入字符串数据 
16.         String str = " hello boy"; 
17.         fwr.write(str); 
18.         //4.清空缓存区 
19.         fwr.flush(); 
20.         //5.关闭输出流 
21.         fwr.close(); 
22.     } 
23. } 

读取字符类型的文件：

1. import java.io.File; 
2. import java.io.FileNotFoundException; 
3. import java.io.FileReader; 
4. import java.io.IOException; 
5.  
6. public class FileDemo01 { 
7.  
8.     /** 
9.      * 文件读操作 
10.      */ 
11.     public static void main(String[] args) { 
12.         // TODO Auto-generated method stub 
13.         // 1.使用File对象指定从哪个文件读出数据 
14.         File f = new File("c:" + File.separator + "test.txt"); 
15.         // 2.定义输入流读入指定的文件 
16.         FileReader fr = null; 
17.         if (!f.exists()) { 
18.             System.out.print("Cannot find the file specified"); 
19.             System.exit(1); 
20.         } 
21.         try { 
22.             fr = new FileReader(f); 
23.         } catch (FileNotFoundException e) { 
24.             e.printStackTrace(); 
25.         } 
26.         // 3.开始读取数据到指定的缓冲区，读完后关闭输入流 
27.         char[] buf = new char[(int) f.length()]; 
28.         try { 
29.             fr.read(buf); 
30.             fr.close(); 
31.         } catch (IOException e) { 
32.             e.printStackTrace(); 
33.         } 
34.         // 4.打印读出的内容 
35.         System.out.print(buf); 
36.     } 
37. } 

字节流操作

写字节到文件的例子：

1. import java.io.File; 
2. import java.io.FileNotFoundException; 
3. import java.io.FileOutputStream; 
4. import java.io.IOException; 
5.  
6. public class FileDemo02 { 
7.  
8.     /** 
9.      * @param args 
10.      */ 
11.     public static void main(String[] args) { 
12.         // TODO Auto-generated method stub 
13.         // 定义写入的文件 
14.         File f = new File("c:" + File.separator + "test.txt"); 
15.         // 定义一个输出流对象 
16.         FileOutputStream fos = null; 
17.         try { 
18.             // 将输出流指定到文件本身 
19.             fos = new FileOutputStream(f, true); 
20.         } catch (FileNotFoundException e) { 
21.             e.printStackTrace(); 
22.         } 
23.         // 指定要写入的数据，将其转化为字节数组 
24.         String str = "hello world"; 
25.         byte[] b = str.getBytes(); 
26.         try { 
27.             // 写入字节数组到输出流中 
28.             fos.write(b); 
29.             // 关闭输出流 
30.             fos.close(); 
31.         } catch (IOException e) { 
32.             e.printStackTrace(); 
33.         } 
34.  
35.     } 
36. } 

读字节类型的文件的例子：

1. import java.io.File; 
2. import java.io.FileInputStream; 
3. import java.io.FileNotFoundException; 
4. import java.io.IOException; 
5.  
6. public class FileDemo02 { 
7.  
8.     /** 
9.      * @param args 
10.      */ 
11.     public static void main(String[] args) { 
12.         // TODO Auto-generated method stub 
13.         // 定义要读出的文件 
14.         File f = new File("c:" + File.separator + "test.txt"); 
15.         // 定义一个输入流对象 
16.         FileInputStream fis = null; 
17.         // 判断文件是否存在 
18.         if (!f.exists()) { 
19.             System.out.print("the file is not exist"); 
20.             System.exit(1); 
21.         } 
22.         try { 
23.             // 将输入流指定到文件本身 
24.             fis = new FileInputStream(f); 
25.         } catch (FileNotFoundException e) { 
26.             e.printStackTrace(); 
27.         } 
28.         // 指定一个字节数组来存储读出的字节 
29.         byte[] b = new byte[(int) f.length()]; 
30.         try { 
31.             // 从字节输入流中读出字节到字节数组中 
32.             fis.read(b); 
33.             // 关闭输出流 
34.             fis.close(); 
35.         } catch (IOException e) { 
36.             e.printStackTrace(); 
37.         } 
38.         // 打印读出的字节并转换成字符显示 
39.         System.out.print(new String(b)); 
40.  
41.     } 
42. } 

附：通常在文件较大时，可以采用如下方式一个一个的读取,防止内存不够或读取缓慢：

1. import java.io.File; 
2. import java.io.FileInputStream; 
3. import java.io.FileNotFoundException; 
4. import java.io.IOException; 
5.  
6. public class FileDemo02 { 
7.  
8.     /** 
9.      * @param args 
10.      */ 
11.     public static void main(String[] args) { 
12.         // TODO Auto-generated method stub 
13.         // 定义要读出的文件 
14.         File f = new File("c:" + File.separator + "test.txt"); 
15.         // 定义一个输入流对象 
16.         FileInputStream fis = null; 
17.         // 判断文件是否存在 
18.         if (!f.exists()) { 
19.             System.out.print("the file is not exist"); 
20.             System.exit(1); 
21.         } 
22.         try { 
23.             // 将输入流指定到文件本身 
24.             fis = new FileInputStream(f); 
25.         } catch (FileNotFoundException e) { 
26.             e.printStackTrace(); 
27.         } 
28.         // 指定一个字节数组来存储读出的字节 
29.         byte[] b = new byte[(int) f.length()]; 
30.         try { 
31.             // 一个一个字节的读取 
32.             // 定义返回的字节 
33.             int temp = 0; 
34.             // 定义一个字节数组的长度 
35.             int len = 0; 
36.             // 循环读取，直到read()返回-1，即指明文件已经到末尾，读完 
37.             while ((temp = fis.read()) != -1) { 
38.                 // 将读取的字节存入到字节数组中 
39.                 b[len] = (byte) temp; 
40.                 len++; 
41.             } 
42.             // 关闭输出流 
43.             fis.close(); 
44.         } catch (IOException e) { 
45.             e.printStackTrace(); 
46.         } 
47.         // 打印读出的字节并转换成字符显示 
48.         System.out.print(new String(b)); 
49.  
50.     } 
51. } 

字符流需要缓冲区的支持，而字节流不需要缓冲区的支持即可对文件本身进行读写。其实缓冲区就是一块 内存区域。如果想要强制性的清空缓冲区，可以使用FileWriter.flush()方法。一般情况下，文件多是 二进制形式，所以字节流用的较多。

下面是一个文件复制的例子： 一次性读取然后一次性写入

1. import java.io.File; 
2. import java.io.FileInputStream; 
3. import java.io.FileOutputStream; 
4. import java.io.IOException; 
5.  
6. public class FileCopy { 
7.  
8.     /** 
9.      * @param args 
10.      */ 
11.     public static void main(String[] args) { 
12.         // TODO Auto-generated method stub 
13.         // 判断命令是否正确 
14.         if (args.length != 2) { 
15.             System.out.println("wrong command"); 
16.             System.out.println("使用命令：FileCopy 源文件路径 目标文件路径"); 
17.             System.exit(1); 
18.         } 
19.         // 定义源文件和目标文件 
20.         File sf = new File(args[0]); 
21.         File df = new File(args[1]); 
22.         // 调用filecopy方法 
23.         fileCopy(sf, df); 
24.     } 
25.  
26.     public static void fileCopy(File sf, File df) { 
27.         // 定义输入流和输出流 
28.         FileInputStream fis = null; 
29.         FileOutputStream fos = null; 
30.         // 定义一个数据传输中间变量 
31.         byte[] buf = null; 
32.         // 判断源文件是否存在 
33.         if (!sf.exists()) { 
34.             System.out.println("The source file is not exist"); 
35.             System.exit(1); 
36.         } 
37.         // 读取指定源文件的内容并存到中间变量 
38.         try { 
39.             fis = new FileInputStream(sf); 
40.             byte[] b = new byte[(int) sf.length()]; 
41.             buf = b; 
42.             int len = 0, temp = 0; 
43.             while ((temp = fis.read()) != -1) { 
44.                 b[len] = (byte) temp; 
45.                 len++; 
46.             } 
47.             fis.close(); 
48.         } catch (IOException e) { 
49.             e.printStackTrace(); 
50.         } 
51.         // 将中间变量中的内容写入到目标文件中 
52.         try { 
53.             fos = new FileOutputStream(df); 
54.             fos.write(buf); 
55.             fos.close(); 
56.             System.out.println("success"); 
57.         } catch (IOException e) { 
58.             e.printStackTrace(); 
59.         } 
60.     } 
61. } 

边读边写入

 

1. import java.io.File; 
2. import java.io.FileInputStream; 
3. import java.io.FileOutputStream; 
4. import java.io.IOException; 
5.  
6. public class FileCopy { 
7.  
8.     /** 
9.      * @param args 
10.      */ 
11.     public static void main(String[] args) { 
12.         // TODO Auto-generated method stub 
13.         // 判断命令是否正确 
14.         if (args.length != 2) { 
15.             System.out.println("wrong command"); 
16.             System.out.println("使用命令：FileCopy 源文件路径 目标文件路径"); 
17.             System.exit(1); 
18.         } 
19.         // 定义源文件和目标文件 
20.         File sf = new File(args[0]); 
21.         File df = new File(args[1]); 
22.         // 调用filecopy方法 
23.         fileCopy(sf, df); 
24.     } 
25.  
26.     public static void fileCopy(File sf, File df) { 
27.         // 定义输入流和输出流 
28.         FileInputStream fis = null; 
29.         FileOutputStream fos = null; 
30.         // 判断源文件是否存在 
31.         if (!sf.exists()) { 
32.             System.out.println("The source file is not exist"); 
33.             System.exit(1); 
34.         } 
35.         // 指定源文件和目标文件并挂到输入流和输出流对象中 
36.         try { 
37.             fis = new FileInputStream(sf); 
38.             fos = new FileOutputStream(df); 
39.             // 边读边写入 
40.             int temp = 0; 
41.             while ((temp = fis.read()) != -1) { 
42.                 fos.write(temp); 
43.             } 
44.             fis.close(); 
45.             fos.close(); 
46.             System.out.println("copy success"); 
47.         } catch (IOException e) { 
48.             e.printStackTrace(); 
49.             System.out.println("copy fail"); 
50.         } 
51.     } 
52. }