Java之IO流学习总结 (转载备忘)

转载自：http://88889999.iteye.com/blog/1617423

 

因近段时间项目频繁使用了IO流，之前我没有系统的学习这方面的知识，在使用时感觉有点迷糊，IO流是Java核心技术的一个高级应用，使用非常频繁，遂在网上找了这方面的资料系统的学习了一下，现把学习成果贴与大家分享，万物皆有裂痕，请各位大神多提出问题一起探讨，共同进步。先来看一个IO流对象继承关系图，现在还不会UML，画的图没有那么专业，就将就着看吧，等我学好了UML再改回来：

其他常用与流有关的对象：

 

 

一、什么是流？

流就是字节序列的抽象概念，能被连续读取数据的数据源和能被连续写入数据的接收端就是流，流机制是Java及C++中的一个重要机制，通过流我们可以自由地控制文件、内存、IO设备等数据的流向。而IO流就是用于处理设备上的数据，如：硬盘、内存、键盘录入等。IO流根据处理类型的不同可分为字节流和字符流，根据流向的不同可分为输入流和输出流。

 

二、字节流和字符流的区别：
字符流，因为文件编码的不同，就有了对字符进行高效操作的字符流对象，它的原理就是基于字节流读取字节时去查了指定的码表。它和字节流的区别有两点：1.在读取数据的时候，字节流读到一个字节就返回一个字节，字符流使用了字节流读到一个或多个字节（一个中文对应的字节数是两个，在UTF-8码表中是3个字节）时，先去查指定的编码表，再将查到的字符返回；2.字节流可以处理所有类型的数据，如jpg、avi、mp3、wav等等，而字符流只能处理字符数据。所以可以根据处理的文件不同考虑使用字节流还是字符流，如果是纯文本数据可以优先考虑字符流，否则使用字节流。

三、IO体系，所具备的基本功能就是读和写：
1.字符流

|-- Reader（读）

|-- Writer（写）

Reader

|--InputStreamReader

|--FileReader：用于处理文件的字符读取流对象

Writer

|--OutputStreamWriter

|--FileWriter：用于处理文件的字符写入流对象

其实很容易就可以看出来，IO体系中的子类名后缀绝大部分是父类名称，而前缀则是体现子类特有功能的名称。

Reader中常见的方法：

|--int read()

读取一个字符，并返回读到的这个字符，读到流的末尾则返回-1。

|--int read(char[])

将读到的字符存入指定的数组中，返回的是读到的字符个数，

读到流的末尾则返回-1。

|--close()

读取字符其实用的是window系统的功能，就希望使用完毕后，

进行资源的释放。

FileReader除了自己的构造函数外没有特有的方法：

|--用于读取文本文件的流对象。

|--用于关联文本文件。

|--构造函数FileReader(String fileName)

在读取流对象初始化时，必须要指定一个被读取的文件，

如果该文件不存在则会发生FileNotFoundException异常。

Writer中常见的方法：

|--write()

将一个字符写入到流中。

|--write(char[])

将一个字符数组写入到流中。

|--writer(String)

将一个字符写入到流中。

|--flush()

刷新流，将流中的数据刷新到目的地中，流还存在。

|--close()

关闭资源，在关闭钱会先调用flush()， 刷新流中的数据到目的地。

FileWriter，除了自己的构造函数外没有特有的方法：

|--该类的特点

|--用于处理文本文件

|--没有默认的编码表

|--有临时缓冲

|--构造函数，在写入流对象初始化时，必须要有一个存储数据的目的地。

|--FileWriter(String fileName)，该构造器是干什么用的呢？

|--调用系统资源

|--在指定位置创建一个文件，如果该文件已经存在则被覆盖。

|--FileWriter(String filename,Boolean append)，这构造器的作用是？

当传入的boolean类型的值为true时，会在指定文件末尾处进行数据的续写。

 

private static void test1(){
    FileWriter fw=null;
    try {
        //初始化FileWriter对象，指定文件名已经存储路径
        fw=new FileWriter("D:/test.txt");
        fw.write("将字符串写入流");
        //将流中的数据刷新到目的地，流还在
        fw.flush();
        fw.write("将字符串写入流");
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        if(fw!=null){
            try {
                fw.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }

        }
    }
}

 

 

 

private static void test2(){
    FileReader fr=null;
    try {
        //初始化FileReader对象，指定文件路径
        fr=new FileReader("D:/test.txt");
        int ch=0;
        while((ch=fr.read())!=-1){
            //每次读取一个字符，直到读到末尾-1为止
            System.out.println((char)ch);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        if(fr!=null){
            try {
                fr.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }

        }
    }
}

这样每读到一个字符就打印出来，效率很不高，能不能按指定大小读取完后再打印出来呢？答案是当然可以的。

 

private static void test3(){
    FileReader fr=null;
    try {
        //初始化FileReader对象，指定文件路径
        fr=new FileReader("D:/test.txt");
        char[] buf=new char[1024];
        int len=0;
        while((len=fr.read(buf))!=-1){
            //每次读取1kb大小的字符，直到读到末尾-1为止
            System.out.println(new String(buf,0,len));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        if(fr!=null){
            try {
                fr.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }

        }
    }
}

 

 

字符流的缓冲区：

|--缓冲区的出现提高了对流的操作效率。

原理：其实就是将数组进行封装。

|--对应的对象

|--BufferedWriter

特有方法newLine()，跨平台的换行符。

|--BufferedReader

特有方法readLine()，一次读一行，到行标记时，将行标记

之前的字符数据作为字符串返回，读到末尾返回null。

|--说明

在使用缓冲区对象时，要明确，缓冲的存在是为了增强流

的功能而存在，所以在建立缓冲区对象时，要先有流对象

存在。其实缓冲区内部就是在使用流对象的方法，只不过

加入了数组对数据进行了临时存储，为了提高操作数据的

效率。

|--代码上的体现

|--写入缓冲区对象

根据前面所说的建立缓冲区时要先有流对象，并将其作为参数传递给缓冲区的构造函数

BufferedWriter bufw=new BufferedWriter(new FileWriter(“test.txt”));

bufw.write(“将数据写入缓冲区”);

bufw.flush();//将缓冲区的数据刷新到目的地

bufw.close();//其实关闭的是被包装在内部的流对象

|--读取缓冲区对象

BufferedReader bufr=new BufferedReader(new FileReader(“test.txt”));

String line=null;

while((line=bufr.readLine())!=null){

//每次读取一行，取出的数据不包含回车符

system.out.println(line);

}

bufr.close();

 

 

private static void test4(){
    BufferedReader bufr=null;
    BufferedWriter bufw=null;
    try {
        /*
         * 缓冲对象依赖于流对象，所以要先创建流对象
         */
        bufr=new BufferedReader(new FileReader("D:/a.txt"));
        bufw=new BufferedWriter(new FileWriter("D:/b.txt"));
        String line=null;
        while((line=bufr.readLine())!=null){
            bufw.write(line);//每次将一行写入缓冲区
            bufw.flush();//刷新到目的地
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        try {
            if(bufw!=null){
                bufw.close();
            }
            if(bufr!=null){
                bufr.close();
            }
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }
}

 仔细看可以发现，程序里面的FileReader对象和FileWriter对象直接new出来且没有调用close()，因为缓冲对象调用了这两个方法，前面说了，缓冲对象调用的flush()和close()其实就是关闭被包装在其内部的流对象。关闭流的先后顺序也要注意，如果流之间有依赖关系，则被依赖的流要后关闭。readLine()方法原理：其实缓冲区中的该方法，用的还是与缓冲区关联的流对象的read方法，只不过，每一次读到一个字符先不进行具体操作，先进行临时存储，当读到回车标记时，将临时容器中存储的数据一次性返回。我们可以根据这个原理来自己编写一个缓冲区对象。

 

/**
 * @fileName MyBufferedReader.java
 * @description 根据readLine()原理
 *              写一个自己的缓冲对象
 * @date 2012-7-25
 * @time 17:45
 * @author wst
 */
public class MyBufferedReader {
    private Reader reader;
    public MyBufferedReader(Reader reader){
        this.reader=reader;
    }

    public String readLine() throws IOException{
        StringBuilder sb=new StringBuilder();
        int ch=0;
        while((ch=reader.read())!=-1){
            if(ch=='\r'){//空格则继续
                continue;
            }else if(ch=='\n'){//每次返回一行
                return sb.toString();
            }else{
                sb.append((char)ch);
            }
        }
        return sb.toString();
    }


    public void close() throws IOException{
        //缓冲对象的关闭方法其实就是调用流本身的close()
        reader.close();
    }
}

 测试时把清单4的BufferedReader对象替换成MyBufferedReader对象即可。

 

private static void test4(){
    MyBufferedReader bufr=null;
    BufferedWriter bufw=null;
    try {
        /*
         * 缓冲对象依赖于流对象，所以要先创建流对象
         */
        bufr=new MyBufferedReader(new FileReader("D:/a.txt"));
        bufw=new BufferedWriter(new FileWriter("D:/b.txt"));
        String line=null;
        while((line=bufr.readLine())!=null){
            bufw.write(line);//每次将一行写入缓冲区
            bufw.flush();//刷新到目的地
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally{
        try {
            if(bufw!=null){
                bufw.close();
            }
            if(bufr!=null){
                bufr.close();
            }
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }
}

 其实我们自己写的这个缓存对象就是对Reader对象进行了功能的增强，Reader对象每次只能返回一个字符，而增强了功能之后该类就可以每次返回一行字符，也就是设计模式中所说的装饰模式。

 

2.字节流

|-- InputStream（读）

|-- OutputStream（写）

由于字节是二进制数据，所以字节流可以操作任何类型的数据，值得注意的是字符流使用的是字符数组char[]而字节流使用的是字节数组byte[]。下面来看一个字节流读写文件的简单例子。

private static void test5(){
    FileOutputStream fos=null;
    try{
        fos=new FileOutputStream("D:/test.txt");
        fos.write(0010);//写入二进制数据
        fos.flush();
    }catch(IOException e){

    }finally{
        try{
            fos.close();
        }catch(IOException ex){

        }
    }
    FileInputStream fis=null;
    try{
        fis=new FileInputStream("D:/test.txt");
        //fis.available()是获取关联文件的字节数，即test.txt的字节数
        //这样创建的数组大小就和文件大小刚好相等
        //这样做的缺点就是文件过大时，可能超出jvm的内存空间，从而造成内存溢出
        byte[] buf=new byte[fis.available()];
        fis.read(buf);
        System.out.println(new String(buf));
    }catch(IOException e){

    }finally{
        try{
            fos.close();
        }catch(IOException ex){

        }
    }
}

 

 

private static void test6(){
    BufferedOutputStream bos=null;
    BufferedInputStream bis=null;
    try{
        //前面已经说过了，缓冲对象是根据具体的流对象创建的，所以必须要有流对象
        bis=new BufferedInputStream(new FileInputStream("E:\\images\\wo\\1.jpg"));
        //写入目标地址
        bos=new BufferedOutputStream(new FileOutputStream("E:\\test.jpg"));
        byte[] buf=new byte[1024];
        while((bis.read(buf))!=-1){
            bos.write(buf);
        }
        bos.flush();
    }catch(IOException e){
        e.toString();
    }finally{
        try{
            if(bos!=null){
                bos.close();
            }
            if(bis!=null){
                bis.close();
            }
        }catch(IOException ex){
            ex.toString();
        }
    }
}

 

 

 

3.转换流

    特点

        |--是字节流和字符流之间的桥梁

       |--该流对象可以对读取到的字节数据进行指定编码表的编码转换

    何时使用

       |--当字节和字符之间有转换动作时

       |--流操作的数据需要进行编码表的指定时

    具体对象体现

       |--InputStreamReader：字节到字符的桥梁

       |--OutputStreamWriter：字符到字节的桥梁

    说明

       这两个流对象是字符流体系中的成员，它们有转换的作用，而本身又是字符流，

所以在new的时候需要传入字节流对象。

    构造函数

       |--InputStreamReader(InputStream)

           通过该构造函数初始化，使用的是系统默认的编码表GBK。

       |--InputStreamReader(InputStream,String charset)

           通过该构造函数初始化，可以通过charset参数指定编码。

       |--OutputStreamWriter(OutputStream)

           使用的是系统默认的编码表GBK。

       |--OutputStreamWriter(OutputSream,String charset)

           通过该构造函数初始化，可以通过参数charset指定编码。

    操作文件的字符流对象是转换流的子类

       |--Reader

           |--InputStreamReader（转换流）

              |--FileReader（文件字符流）

       |--Writer

           |--OutputStreamWriter（转换流）

              |--FileWriter（文件字符流）

    说明

       转换流中的read方法，已经融入了编码表，在底层调用字节流的

       read方法时将获取的一个或者多个字节数据进行临时存储，并去

       查指定的编码表，如果编码没有指定，则使用默认编码表。

       既然转换流已经完成了编码转换的动作，对于直接操作的文本文
       件的FileReader而言，就不用再重新定义了，只要继承该转换

       流，获取其方法，就可以直接操作文本文件中的字符数据了。

    注意

       在使用FileReader操作文本数据时，该对象使用的是默认的编码表，

       如果要使用指定的编码表，必须使用转换流。

    代码体现

        FileReader fr=new FileReader(“test.txt”);
        InputStreamReader isr=new InputStreamReader(new

FileInputStreamReader(“test.txt”));

这两句代码意义相同，操作test.txt中的数据都是使用了系统默认

的编码GBK。因为我们系统默认使用的编码表是GBK，如果test.txt中

的数据是通过UTF-8形式编码的，那么在读取的时候就需要指定编码表，

因此转换流必须使用InputStreamReader isr=new

InputStreamReader(new FileInputStream(“a.txt”),”UTF-8”);

 

四、流操作的基本规律

|--明确数据源和数据汇（数据目的）

其实是为了明确是输入流还是输出流

|--明确操作的数据是否是纯文本数据

|--说明

数据源

     键盘System.in、硬盘、File开头的流对象、内存（数组）。

数据汇

     控制台System.out、硬盘、File开头的流对象、内存（数组）。

|--需求

将键盘录入的数据存储到一个文件中和打印到控制台

     |--数据源System.in

        既然是源，使用的就是输入流，可用的体系有InputStream

        、Reader。因为键盘录入进来的一定是纯文本数据，所以

        可以使用专门操作字符数据的Reader。而System.in对应

        的流是字节读取流，所以要将其进行转换，将字节转换成字

符即可，所以要使用Reader体系中的InputStreamReader，

如果要提高效率，就使用BufferedReader，代码如：

BufferedReader bur=new BufferedReader(new

InputStreamReader(Sysem.in));

           |--数据汇：一个文件、硬盘

              数据汇一定是输出流，可以用的体系有OutputStream、

              Writer。往文件中存储的都是文本数据，那么可以使用字符

              流较为方便Writer。因为操作的是一个文件，所以使用Writer

              中的FileWriter，同理，要提高效率就要使用BufferedWriter。

              代码如：BufferedWriter bufr=new BufferedWriter(new

FileWriter(“test.txt”));

 

 

private static void test7(){
    BufferedReader bur=null;
    OutputStreamWriter osw=null;
    BufferedWriter bw=null;
    try{
        //数据源
        bur=new BufferedReader(new InputStreamReader(System.in));
        //数据汇
        osw=new OutputStreamWriter(System.out);
        //数据汇，因为数据源用的是系统默认编码，所以这里可以直接使用FileWriter
        //否则必须使用OutputStreamWriter转换流
        bw=new BufferedWriter(new FileWriter("D:\\test_target.txt"));
        String line=null;
        while((line=bur.readLine())!=null){
            osw.write(line);
            osw.flush();//刷新到控制台
            bw.write(line);
            bw.flush();//刷新到文本文件
        }
    }catch(IOException e){
        e.toString();
    }finally{
        try{
            if(osw!=null){
                osw.close();
            }
            if(bur!=null){
                bur.close();
            }
            if(bw!=null){
                bw.close();
            }
        }catch(IOException ex){
            ex.toString();
        }
    }
}

 清单9是按照默认编码表写入文本文件的，那么如何按照指定编码表写入文件呢？其实也很简单，将清单9的代码稍微改一下就可以了。

 

private static void test8(){
    BufferedReader bur=null;
    BufferedWriter bw=null;
    try{
        //数据源
        bur=new BufferedReader(new InputStreamReader(System.in));
        //数据汇，按照指定编码格式存储到文本文件
        bw=new BufferedWriter(new OutputStreamWriter(new
        FileOutputStream("D:\\test_target.txt"),"UTF-8"));
        String line=null;
        while((line=bur.readLine())!=null){
            bw.write(line);
            bw.flush();//刷新到文本文件
        }
    }catch(IOException e){
        e.toString();
    }finally{
        try{
            if(bur!=null){
                bur.close();
            }
            if(bw!=null){
                bw.close();
            }
        }catch(IOException ex){
            ex.toString();
        }
    }
}

 

 

既然写入文件时指定了编码，那么在读取的时候就必须指定该编码才能正确显示。

 

private static void test9() {
    BufferedReader bur = null;
    try {
        // 注意，这里读取的是清单8写入的文件，
        // 清单10用UTF-8编码格式写入，
        // 所以在构造InputStreamReader时必须指定UTF-8编码
        bur = new BufferedReader(new InputStreamReader(
new FileInputStream("D:\\test_target.txt"), "UTF-8"));
        String line = null;
        while ((line = bur.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.toString();
    } finally {
        try {
            if (bur != null) {
                bur.close();
            }
        } catch (IOException ex) {
            ex.toString();
        }
    }
}

 

 

写入和读取都做了，现在还差个复制操作，其实复制文件也很简单，先读取文件，再将读取到的数据写入文件，不同的是，在读取和写入时我们可以指定编码表。

 

private static void test11() {
    BufferedReader bur = null;
    BufferedWriter buw = null;
    try {
        bur = new BufferedReader(new InputStreamReader(
new FileInputStream("D:\\test_target.txt"), "UTF-8"));
        buw = new BufferedWriter(new OutputStreamWriter(
        new FileOutputStream("D:\\test_target1.txt"),"UTF-8"));
        String line = null;
        while ((line = bur.readLine()) != null) {
            buw.write(line);
            buw.flush();// 刷新到文本文件
        }
    } catch (IOException e) {
        e.toString();
    } finally {
        try {
            if (buw != null) {
                buw.close();
            }
            if (bur != null) {
                bur.close();
            }
        } catch (IOException ex) {
            ex.toString();
        }
    }
}