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. }