I/O流存储对比

/*
 * 需求：将d:\\test.avi文件进行复制
 *      采用4种方式复制
 *      方式1： 采用基本的流，一次一个字节的方式复制 共耗时 224613毫秒
 *      方式2： 采用基本的流，一个多个字节的方式赋值 共耗时     327毫秒
 *      方式3： 采用高效的流，一次一个字节的方式复制 共耗时    2047毫秒
 *      方式4： 采用高效的流，一个多个字节的方式赋值 共耗时      96毫秒
 * 
 * 数据源： d:\\test.avi
 * 目的地1: d:\\copy1.avi
 * 目的地2: d:\\copy2.avi
 * 目的地3: d:\\copy3.avi
 * 目的地4: d:\\copy4.avi
 * 
 * 实现的步骤：
 *  1，指定数据源
 *  2，指定目的地
 *  3，读数据
 *  4，写数据
 *  5，关闭流
 * 
 */
public class CopyAVI {
    public static void main(String[] args) throws IOException {
        //开始计时
        long start = System.currentTimeMillis();
        //方式1： 采用基本的流，一次一个字节的方式复制
        //method1("d:\\test.avi", "d:\\copy1.avi");
        //方式2： 采用基本的流，一个多个字节的方式赋值
        //method2("d:\\test.avi", "d:\\copy2.avi");
        //方式3： 采用高效的流，一次一个字节的方式复制
        //method3("d:\\test.avi", "d:\\copy3.avi");
        //方式4： 采用高效的流，一个多个字节的方式赋值
        method4("d:\\test.avi", "d:\\copy4.avi");
        
        //结束计时
        long end = System.currentTimeMillis();
        //打印耗时多少毫秒
        System.out.println("共耗时 " +(end - start)+ "毫秒");
    }
    
    //方式4： 采用高效的流，一个多个字节的方式赋值
    private static void method4(String src, String dest) throws IOException {
        //1，指定数据源
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
         //2，指定目的地
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));
         //3，读数据
        byte[] buffer = new byte[1024];
        int len = -1;
        while ( (len = in.read(buffer)) != -1) {
            //4,写数据
            out.write(buffer, 0, len);
        }
         //5，关闭流
        in.close();
        out.close();
    }

    //方式3： 采用高效的流，一次一个字节的方式复制
    private static void method3(String src, String dest) throws IOException {
        //1，指定数据源
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
         //2，指定目的地
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));
         //3，读数据
        int ch = -1;
        while ((ch=in.read()) != -1) {
            //4，写数据
            out.write(ch);  
        }       
         //5，关闭流
        in.close();
        out.close();
    }

    //方式2： 采用基本的流，一个多个字节的方式赋值
    private static void method2(String src, String dest) throws IOException {
        //1，指定数据源
        FileInputStream in = new FileInputStream(src);
        //2，指定目的地
        FileOutputStream out = new FileOutputStream(dest);
        //3，读数据
        byte[] buffer = new byte[1024];
        int len = -1;
        while ( (len=in.read(buffer)) != -1) {
            //4，写数据
            out.write(buffer, 0, len);
        }
        //5，关闭流
        in.close();
        out.close();
    }

    //方式1： 采用基本的流，一次一个字节的方式复制
    private static void method1(String src, String dest) throws IOException {
        //1，指定数据源
        FileInputStream in = new FileInputStream(src);
        //2，指定目的地
        FileOutputStream out = new FileOutputStream(dest);
        //3，读数据
        int ch = -1;
        while (( ch=in.read()) != -1) {
            //4，写数据
            out.write(ch);
        }
        //5，关闭流
        in.close();
        out.close();
    }
}

字节流

• 字节输入流 InputStream
• FileInputStream 操作文件的字节输入流
• BufferedInputStream高效的字节输入流
• 字节输出流 OutputStram
• FileOutputStream 操作文件的字节输出流
• BufferedOutputStream 高效的字节输出流\

字符流

• 字符输入流 Reader
• FileReader 操作文件的字符输入流
• BufferedReader 高效的字符输入流
• InputStreamReader 输入操作的转换流(把字节流封装成字符流)
• 字符输出流 Writer
• FileWriter 操作文件的字符输出流
• BufferedWriter 高效的字符输出流
• OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)

方法：

• 读数据方法：
• read() 一次读一个字节或字符的方法
• read(byte[] char[]) 一次读一个数组数据的方法
• readLine() 一次读一行字符串的方法(BufferedReader类特有方法)
• readObject() 从流中读取对象(ObjectInputStream特有方法)
• 写数据方法：
• write(int) 一次写一个字节或字符到文件中
• write(byte[] char[]) 一次写一个数组数据到文件中
• write(String) 一次写一个字符串内容到文件中
• writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)
• newLine() 写一个换行符号(BufferedWriter类特有方法)

向文件中写入数据的过程

1，创建输出流对象
2，写数据到文件
3，关闭输出流

从文件中读数据的过程

1， 创建输入流对象
2， 从文件中读数据
3， 关闭输入流

文件复制的过程

1， 创建输入流（数据源）
2， 创建输出流（目的地）
3， 从输入流中读数据
4， 通过输出流，把数据写入目的地
5， 关闭流