黑马程序员_Java基础：IO流总结

　　------- android培训、java培训、期待与您交流！ ----------

       IO流在是java中非常重要，也是应用非常频繁的一种技术。初学者要是能把IO技术的学透，java基础也就能更加牢靠。本文是根据以前学习IO的过程中的一些总结，再通过查找资料完善出来的，应该算是比较适合初学者解读的。

一、概念

       流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输。所以，为了方便更直观的进行数据操作，就根据数据传输特性将流抽象为各种类。

       一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。

       流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。

       我们可以把形象的比喻成水流 ，文件和程序之间连接一个管道，水流就在之间形成了,自然也就出现了方向：可以流进，也可以流出。

 

二、流的分类

       1.根据从流本身的特点来说，可以分为结点流(nodestream)和过滤流(filters)。

   （1）结点流直接从指定的位置（如磁盘文件或内存区域）读或写。（如FileOutputStream和FileInputstream）
   （2）过滤流输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤流输出流的原理也类似。（如ObjectOutputStream和ObjectInputStream）

 

       2.根据流操作对象的类型是字节还是字符可分为两大类： 字节流和字符流。

   （1）字节流，顾名思义，是操作字节的流，而字节也是最基本的存储单位，所以字节流是最基本的流。它对应有字节输入流和字节输出流（Inputstream和OutputStream）。
   （2）字符流，是操作字符的流。我们应该知道，字符是从字节根据编码表编码而来的，而编码表不是唯一的，这就造成了同样的字节数据，如果根据的编码表不一样，那么最终得到的字符也就不一样。所以为了对字符进行高效操作，就有了字符流。总的来说，字符流本质上是基于字节流读取时，查询了指定的码表。字符流也对应有字符输入流和字符输出流（Reader和Writer）。

 

       字节流和字符流的区别可以归纳一下：

   （1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
   （2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
   （3）字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件。

 

三、一般使用原则

     java类库中，还包含很多流对象，我们可以看一下他们的派生关系，如下图示意：

    那么，这么多的流对象，使用中如何选择？

    我们先把流对象按特点划分一下：

    1.按数据来源和目的：  
    （1）是文件： FileInputStream, FileOutputStream, FileReader, FileWriter  
    （2）是byte[]：ByteArrayInputStream, ByteArrayOutputStream   
    （3）是Char[]: CharArrayReader, CharArrayWriter  
    （4）是String: StringBufferInputStream, StringReader, StringWriter  
    （5）网络数据流：InputStream, OutputStream, Reader, Writer  
 
    2.按是否格式化输出：  
    要格式化输出：PrintStream,PrintWriter  
 
    3.按是否要缓冲：  
    要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader,BufferedWriter 
 
    4.按数据格式：  
    （1）二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类  
   （2）纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类  
 
   5.按输入输出：  
    （1）输入：Reader, InputStream类型的子类  
   （2）输出：Writer, OutputStream类型的子类  
      
    6.特殊需要：   
    （1）从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter   
    （2）对象输入输出：ObjectInputStream, ObjectOutputStream  
   （3）进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter  
   （4）合并输入：SequenceInputStream   
   （5）更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream,LineNumberReader

 

    基于以上各个流的特点，我们在使用IO流时，可按一下步骤判断选择：

   （1）考虑最原始的数据格式是什么：是否为文本？
   （2）是输入还是输出?
   （3）是否需要转换流：InputStreamReader, OutputStreamWriter?
   （4）数据来源和目的是什么：文件？内存？网络？
   （5）是否要缓冲：bufferedReader等 ?
   （6）是否要格式化输出：print?

 

四、应用

    1.例子一（字节流复制图片）：

import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;/*要求：复制一张图片。需求分析：1，原始的数据格式是什么：是否为文本？原始数据是图片，所以用字节流。2，是输入还是输出? 需要复制，所以需要输入和输出。3，是否需要转换流?因为操作过程中只涉及字节，所以不需要转换流。4，数据来源和目的是什么：文件？内存？网络？数据源是硬盘，写入目的地也是硬盘。所以使用FileInputStream和FileOutputStream。5，是否要缓冲？不需要使用缓冲。6，是否要格式化输出？不需要格式化输出。思路：1，用字节读取流对象和图片关联。2，用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。3，通过循环读写，完成数据存储。4，关闭资源。 */public class CopyPicTest {    public static void main(String[] args) {        FileOutputStream fos = null;        FileInputStream fis = null;                try        {//            定义读取和写入目的文件。如果文件在多层路径下，可以先定义File。            fos = new FileOutputStream("d:\\Miku_Toxic_Copy.jpg");            fis = new FileInputStream("c:\\Miku_Toxic.jpg");                        byte[] buf = new byte[1024*4];　　//先把字节写入到字节数组中。            int len = 0;                        while ((len=fis.read(buf))!=-1)            {                fos.write(buf,0,len);　　　　//再把字节数组中的元素写入目的文件。            }        }        catch (IOException e)        {            throw new RuntimeException("复制文件失败");        }        finally        {            try            {                if(fis!=null)                    fis.close();            }            catch (IOException e1)            {                throw new RuntimeException("读取关闭失败");            }                        try            {                if(fos!=null)                    fos.close();　　// 流使用完必须要关闭，释放系统资源。在finally块中关闭就是为了保证执行关闭动作。            }            catch (IOException e1)            {                throw new RuntimeException("写入关闭失败");            }        }    }} 

    需要注意的是，任何流最终都必须要关闭，释放系统资源。所以可以把关闭资源的动作，放在fially块中来保证执行。

 

    2.例子二（字符流复制文本文件）：（为了方便阅读异常做抛处理）

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/*要求：复制文本文件。需求分析：1，原始的数据格式是什么：是否为文本？原始数据是文本文件，所以用字符流。2，是输入还是输出? 需要复制，所以需要输入和输出。3，是否需要转换流?因为操作过程中只涉及字符，所以不需要转换流。4，数据来源和目的是什么：文件？内存？网络？数据源是硬盘，写入目的地也是硬盘。所以使用FileReader和FileWriter。5，是否要缓冲？有和没有缓冲的情况都有。6，是否要格式化输出？不需要格式化输出。 */public class CopyFileTest {    public static void main(String[] args) throws IOException{        readAndWriteFile_1();        readAndWriteFile_2();        readAndWriteFile_3();    }        public static void readAndWriteFile_1()throws IOException    {        FileReader fr = new FileReader("c:\\fr.txt");        FileWriter fw = new FileWriter("d:\\fw1.txt");                int ch = 0;                while ((ch=fr.read())!=-1) {    //读一个字符，写一个字符。            fw.write(ch);            fw.flush();        //字符流写入时，需要刷新。        }//        流使用完，必须要关闭。        fr.close();        fw.close();    }        public static void readAndWriteFile_2() throws IOException    {        FileReader fr = new FileReader("fos.txt");        FileWriter fw = new FileWriter("d:\\fos2.txt");                char[] cha = new char[1024];        //先把字符写入到字符数组中。        int len = 0;        while ((len=fr.read(cha))!=-1) {            fw.write(cha,0,len);    //再把字符数组中的元素写入目的文件。            fw.flush();        //字符流写入时，需要刷新。        }//        流使用完，必须要关闭。        fr.close();        fw.close();    }        public static void readAndWriteFile_3() throws IOException    {        FileReader fr= new FileReader("fos.txt");        FileWriter fw = new FileWriter("d:\\fos3.txt");//        使用缓冲区。        BufferedReader bufr = new BufferedReader(fr);        BufferedWriter bufw = new BufferedWriter(fw);                String len = null;        while ((len=bufr.readLine())!=null) {    //每次把文本中的一行读进缓冲区（不含换行符）。            bufw.write(len);    //再把一行数据写入目的文件（不含换行符）。            bufw.newLine();        //换行方法。            bufw.flush();        //字符流需要刷新。        }//        流使用完，必须要关闭。        bufr.close();        bufw.close();    }}

    前面有提过，字符流本身实际有使用缓冲技术，所以写入的时候需要手动刷新，让缓冲区的数据（内存）刷新到目的地。

 

    3.例子三（转换流，将键盘录入数据保存为文本文件）

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;/*要求：录入键盘数据，保存到文本文件。需求分析：1，原始的数据格式是什么：是否为文本？源数据是字节流。目的数据是字符流。2，是输入还是输出? 需要读取和写入，所以需要输入和输出。3，是否需要转换流?因为操作过程中有字节和字符，需要转换流。4，数据来源和目的是什么：文件？内存？网络？数据源是键盘录入，写入目的地是硬盘。所以使用InputStreamReader和FileWriter。5，是否要缓冲？需要。使用BufferedReadr和BufferedWriter。6，是否要格式化输出？不需要格式化输出。*/public class TransStream {    public static void main(String[] args) {        System.out.println("请输入要保存到文件中的内容（输入over结束）：");//        System.in录入键盘数据得到的是字节流，如要用字符流的方式读取，必须要先将字节流转成字符流。        InputStreamReader isr = new InputStreamReader(System.in);//        使用缓冲区读写更加效率。        BufferedReader bufr = new BufferedReader(isr);        BufferedWriter bufw = null;        try {//            也可以通过OutputStreamWriter来指定编码表。//            bufw = new BufferedWriter(new OutputStreamWriter("c:\\systemin.txt","UTF-8"));                bufw = new BufferedWriter(new FileWriter("c:\\systemin.txt"));                        String str = null;            while ((str=bufr.readLine())!=null) {                if ("over".equals(str))                    System.exit(0);        //如果键盘录入over，则结束。                bufw.write(str);                bufw.newLine();                bufw.flush();                        }        } catch (IOException e) {                        throw new RuntimeException("找不到目标文件或写入数据失败");        } finally {            try {                if (bufw!=null) {                    bufr.close();                    bufw.close();                }            } catch (IOException e) {                                throw new RuntimeException("关闭资源失败");            }        }    }}

    从以上例子可以看出，转换流是字符流和字节流之间的桥梁，我们实际也可以利用转换流把文本文件中的内容打印到控制台上。也就是说可以通过转换流让字符流和字节流相互转换。

    另外要注意的是，将字节转换成字符的时，想按照指定的码表来转换，也可以通过OutputStreamWriter（OutputStream out，CharsetEncoder enc）的方式指定，其中enc即代表码表的名字，如"UTF-8","ISO 8859-1"等。

 

    4.例子四（利用打印流把键盘录入数据保存到文件）：

import java.io.BufferedReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;/*要求：录入键盘数据，保存到文本文件。需求分析：1，原始的数据格式是什么：是否为文本？源数据是字节流。目的数据是字符流。2，是输入还是输出? 需要读取和写入，所以需要输入和输出。3，是否需要转换流?因为操作过程中有字节和字符，需要转换流。4，数据来源和目的是什么：文件？内存？网络？数据源是键盘录入，写入目的地是硬盘。所以使用InputStreamReader和FileWriter。5，是否要缓冲？需要。使用BufferedReadr。6，是否要格式化输出？需要格式化输出。使用PrintWriter。*/public class PrintStream {    public static void main(String[] args) throws IOException{        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//        PrintWriter可以设置刷新模式，如果刷新模式为true，那么PrintWriter部分方法输出是会自动刷新。        PrintWriter out = new PrintWriter(new FileWriter("c:\\a.txt"),true);        String line = null;        while ((line=bufr.readLine())!=null)        {//            如果键盘输入over，则结束程序。            if("over".equals(line))                break;//            因为PrintWriter设置有刷新模式，不需再手动刷新。            out.println(line.toUpperCase());        }        bufr.close();        out.close();    }}

    看完例子，在看看打印流的特点：

   打印流：
   该流提供了打印方法，可以将各种数据类型的数据都原样打印。

   字节打印流：
   PrintStream
   构造函数可以接收的参数类型：
   （1）file对象。File
   （2）字符串路径。String
   （3）字节输出流。OutputStream

   字符打印流：
   PrintWriter
   构造函数可以接收的参数类型：
   （1）file对象。File
   （2）字符串路径。String
    （3）字节输出流。OutputStream
    （4）字符输出流。Writer

 

    可以看出，字符打印流相对来说适用性更强。

 

    5.例子五（LineNumberReader）：

import java.io.FileReader;import java.io.IOException;import java.io.LineNumberReader;public class LineNumberReaderDemo {    public static void main(String[] args)throws IOException {        FileReader fr = new FileReader("PersonDemo.java");        LineNumberReader lnr = new LineNumberReader(fr);        String line = null;        lnr.setLineNumber(100);        while((line=lnr.readLine())!=null)            System.out.println(lnr.getLineNumber()+":"+line);        lnr.close();    }}

    从 以上例子可以看出，LineNumberReader属于过滤流，而它实际的功能也是在字符写入流的基础上，加上获取行号（getLineNumber()），设置行号（setLineNumber()）的功能。LineNumberOutputStream同理，这里不再做阐述。

 

    6.例子六（数据流）：

import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class DataStreamDemo {    public static void main(String[] args) throws IOException{        writeData();        readData();    }    public static void readData()throws IOException{        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));        int num = dis.readInt();        boolean b = dis.readBoolean();        double d = dis.readDouble();        System.out.println("num="+num);        System.out.println("b="+b);        System.out.println("d="+d);        dis.close();    }    public static void writeData()throws IOException{        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));        dos.writeInt(234);        dos.writeBoolean(true);        dos.writeDouble(9887.543);        dos.close();    }} 

    以上运行结果是：

    234
    true
    9887.543

 

    从例子可以看出数据流的特点：

    DataInputStream和DataOutputStream，经常用来处理基本数据类型的数据，好处就是可以按类型来处理数据。

 

    7.例子七（数组流）：

import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;public class ByteArrayStream {    public static void main(String[] args) {        //数据源。        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());        //数据目的，数组输出流输出的数据目的地是内存。        ByteArrayOutputStream bos = new ByteArrayOutputStream();        int by = 0;        while((by=bis.read())!=-1)            bos.write(by);        System.out.println(bos.size());        System.out.println(bos.toString());//        最后内存中流的数据可以通过writeTo方法输出到其他节点流中，将数据保存到目的地。    //    bos.writeTo(new FileOutputStream("a.txt"));    }}

    运行结果为：

    7
    ABCDEFD

 

    数组流是用于操作字节数组的流对象，它是使用流的思想来操作数据的体现。
    ByteArrayInputStream ：在构造的时候，需要接收数据源，而且数据源是一个字节数组。
    ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组，这就是数据目的地（在内存中）。
    因为这两个流对象都操作的数组，并没有使用系统资源。
    所以，不用进行close关闭。

 

    8.例子八（RandomAccessFile）：

import java.io.IOException;import java.io.RandomAccessFile;public class RandomAccessFileDemo {    public static void main(String[] args) throws IOException{        writeFile();        writeFile_2();        readFile();    }    public static void readFile()throws IOException{        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");        //调整对象中指针，以8为单位是因为两个中文字4个字节加上int数据的4个字节。        //raf.seek(8*1);        //跳过指定的字节数        raf.skipBytes(8);        byte[] buf = new byte[4];        raf.read(buf);        String name = new String(buf);        int age = raf.readInt();        System.out.println("name="+name);    //结果为周七。        System.out.println("age="+age);        raf.close();    }//    也能修改指定指针上的数据。    public static void writeFile_2()throws IOException{        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");        raf.seek(8*0);        raf.write("周七".getBytes());        raf.writeInt(103);        raf.close();    }    public static void writeFile()throws IOException{        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");        raf.write("李四".getBytes());        raf.writeInt(97);        raf.write("王五".getBytes());        raf.writeInt(99);        raf.close();    }}

    运行结果为：

    周七
    103

 

    从前面的派生图可以看出，RandomAccessFile不算是IO体系中子类，而是直接继承自Object。但是它是IO包中成员，因为它具备读和写功能。

    实际上RandomAccessFile内部封装了一个数组，而且通过指针对数组的元素进行操作。
    从例子可以看出通过getFilePointer获取指针位置，同时通过seek改变指针的位置。
    至于RandomAccessFile能够同时实现读和写的功能的原因，其实是是其在内部封装了字节输入流和输出流。
    通过查询API中构造函数可以看出，该类只能操作文件，而且操作文件还有模式：只读r，，读写rw等。
    如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
    如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

 

    9.例子九（管道流）：

import java.io.IOException;import java.io.PipedInputStream;import java.io.PipedOutputStream;class Read implements Runnable {    private PipedInputStream in;    Read(PipedInputStream in){        this.in = in;    }    public void run() {        try {            byte[] buf = new byte[1024];            System.out.println("读取前。。没有数据阻塞");            int len = in.read(buf);            System.out.println("读到数据。。阻塞结束");            String s= new String(buf,0,len);            System.out.println(s);            in.close();        }        catch (IOException e) {            throw new RuntimeException("管道读取流失败");        }    }}class Write implements Runnable {    private PipedOutputStream out;    Write(PipedOutputStream out) {        this.out = out;    }    public void run() {        try {            System.out.println("开始写入数据，等待6秒后。");            Thread.sleep(6000);            out.write("piped lai la".getBytes());            out.close();        }        catch (Exception e) {            throw new RuntimeException("管道输出流失败");        }    }}public class  PipedStreamDemo {    public static void main(String[] args) throws IOException {        PipedInputStream in = new PipedInputStream();        PipedOutputStream out = new PipedOutputStream();//        管道输入流连接到管道输出流。        in.connect(out);        Read r = new Read(in);        Write w = new Write(out);        new Thread(r).start();        new Thread(w).start();    }}

    运行结果为：

    读取前。。没有数据阻塞
    开始写入数据，等待6秒后。
    读到数据。。阻塞结束
    piped lai la

 

    看完例子，再来看看管道流的特点：

    PipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信，多用于多线程中。

    一 个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道。 PipedOutputStream可以向管道中写入数据,PipedIntputStream可以读取PipedOutputStream向管道中写入的数据。

    这两个类主要用来完成线程之间的通信。一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据。

    所以，我们使用管道流时，必须要同时构造管道输入流和管道输出流。

 

    10.例子十（合并流）：

import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.SequenceInputStream;import java.util.ArrayList;import java.util.Enumeration;import java.util.Iterator;public class MergeFile {    public static void main(String[] args) throws IOException {        merge();    }    public static void merge() throws IOException {//        创建集合，泛型为文件字节输入流。        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();        for(int x=1; x<=3; x++)//            将输入流添加进集合中。            al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));        final Iterator<FileInputStream> it = al.iterator();//        因为前面为了更加让程序效率使用了ArrayList，所以这里只能通过匿名内部类自定义Enumeration，实现目的。//        如果前面使用的是Vetor集合，则不需再定义这一步。        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){            public boolean hasMoreElements() {                return it.hasNext();            }            public FileInputStream nextElement() {                return it.next();            }        };        SequenceInputStream sis = new SequenceInputStream(en);        FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");        byte[] buf = new byte[1024];        int len = 0;        while((len=sis.read(buf))!=-1)            fos.write(buf,0,len);        fos.close();        sis.close();    }}

    合并流，SequenceInputStream表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。总而言之，合并流就是用来合并多个字节输出流变成一个字节输出流。

 

    11.例子十一（分割文件）：

import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class SplitFile {    public static void main(String[] args) throws IOException {        splitFile();    }    public static void splitFile()throws IOException {        FileInputStream fis =  new FileInputStream("c:\\1.bmp");        FileOutputStream fos = null;        byte[] buf = new byte[1024*1024];        int len = 0;        int count = 1;        while((len=fis.read(buf))!=-1) {            fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");            fos.write(buf,0,len);            fos.close();        }                 fis.close();            }}

    可以看出，java中并没有可以直接分割流的对象。分割流的方法很多，以上例子主要是通过计数器，和作为缓冲区的数组来控制分割流，然后输出到不同的文件上。

 

    这十一个例子囊括了IO流中最常用的部分，剩余其他的流的使用思想也是相通的，这里就不再阐述了。相信只要认真的去了解学习IO流，以后它就会成为你的好帮手。