java中的io流总结（一）

知识点：基于抽象基类字节流（InputStream和OutputStream）、字符流（Reader和Writer）的特性，处理纯文本文件，优先考虑使用字符流BufferedReader/BufferedWriter，其他的考虑使用字节流(BufferedInputStream/BufferedOutputStream),之所以使用缓冲流读写很快

（一）io结构图

字节流和字符流的区别：

1.字节流处理所有的类型数据，如：图片，视频等等，而字符流只能处理字符数据，如果处理纯文本文件，优先考虑使用字符流，其他的考虑使用字节流；

2.字节流读到一个字节就返回一个字节，字符流使用字节流读到一个或者多个字节，去查编码表，将查到的字符返回（中文对应的字节数为两个）。

（二）示例代码

(1) 节点流  FileInputStream/FileOutStream（字节流）读写文件实现文件的复制

import java.io.*;
/*
IO体系
抽象基类            节点流(文件流)       缓冲流（处理流的一种）
InputStream        FileInputStream       BufferedInputStream
OutputStream       FileOutputStream      BufferedOutputStream (flush)
Reader             FileReader            BufferedReader (readline)
Writer             FileWriter            BufferedWriter (flush)
*/
public class IOTestInputOutputStream {
//复制文件
@Test
public void TestFileInputOutputStream(){
    //TestCopyFile("E:\\test\\io\\test2.txt","E:\\test\\io\\test8.txt"); //复制文本文件
    //TestCopyFile("E:\\test\\io\\1.png","E:\\test\\io\\2.png");//图片
    long start=System.currentTimeMillis();
    TestCopyFile("E:/test/io/1.flv","E:/test/io/2.flv");
    long end=System.currentTimeMillis();
    System.out.println("时间:"+(end-start));//复制视频48.3M需要6151毫秒     
}
public void TestCopyFile(String src,String dest){
        File file1=new File(src);
        File file2=new File(dest);

        FileInputStream fis=null;
        FileOutputStream fos=null;
            try {
                int len;
                byte[] b=new byte[50];
               fis=new FileInputStream(file1);
               fos=new FileOutputStream(file2);

                while (((len=fis.read(b))!=-1)) {
                    fos.write(b,0,len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}
(2) 节点流 FileReader/FileWriter(缓冲流)读写文件实现文件的复制

import java.io.*;
/*
FileReader、FileWriter 可以实现文本文件复制
对于非文本文件（视频文件、音频文件、图片），只能使用字节流
*/
public class FileReaderFileWriter {
    //复制文本文件
    @Test
    public void FileReaderAndFileWriter(){      

      CopyFileRederAndWriter("E:/test/io/3.txt","E:/test/io/4.txt");
      //CopyFileRederAndWriter("E:/test/io/1.png","E:/test/io/3.png"); //文件复制出错
    }
    public void CopyFileRederAndWriter(String src,String desc){
        FileReader fr=null;
        FileWriter fw=null;

        try {
            File file1=new File(src);
            File file2=new File(desc);
            fr=new FileReader(file1);
            fw=new FileWriter(file2);
            char[] c=new char[20];
            int len;
            while ((len=fr.read(c))!=-1){
                String str=new String(c);
                fw.write(str,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(3) 缓冲流 BufferedInputStream/BufferedInputStream 读写文件实现文件的复制
使用缓冲流较文件读写熟读更快，如下例子中读写48.4M的视频文件，文件需要6151毫秒，而缓冲只需要170毫秒，实际应用中使用缓冲流，将文件作为参数传入缓冲中

@Test
public  void testBufferedInputOutputStream(){
    long start=System.currentTimeMillis();
    CopyBufferedInputOutputStream("E:/test/io/1.flv","E:/test/io/2.flv");
    long end=System.currentTimeMillis();
    System.out.println("时间:"+(end-start));//复制视频48.3M需要170毫秒,较节点流速度快
}

public void CopyBufferedInputOutputStream(String src,String desc){
    BufferedInputStream bis=null;
    BufferedOutputStream bos=null;

    try {
        File file1=new File(src);
        File file2=new File(desc);

        FileInputStream fis=new FileInputStream(file1);
        FileOutputStream fos=new FileOutputStream(file2);

        bis=new BufferedInputStream(fis);
        bos=new BufferedOutputStream(fos);
        byte[] b=new byte[50];
        int len;
        while ((len=bis.read(b))!=-1){
            bos.write(b,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //先关闭输出流，后关闭输入流
        if (bos!=null){
            try {
                bos.flush();//清空缓冲区内的数据，最后一次
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bis!=null){
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

(4) 缓冲流 BufferedReader/BufferedWriter读写文件实现文件的复制

@Test
public void testBufferedReaderAndWriter(){
    BufferedReader br=null;
    BufferedWriter bw=null;

    try {
        File file1=new File("E:/test/io/3.txt");
        File file2=new File("E:/test/io/5.txt");
        FileReader fr=new FileReader(file1);
        FileWriter fw=new FileWriter(file2);
        br=new BufferedReader(fr);
        bw=new BufferedWriter(fw);

       String str;
       while ((str=br.readLine())!=null){//按行读
          // System.out.println(str+"\n");
           bw.write(str+"\n");//换行写
          // bw.newLine();//换行写
       }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
         if (bw!=null){
            try {
                bw.flush();//清空缓冲区内的数据,最后一次
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (br!=null){
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
       
    }
}