java之I/O流

I/O流的使用情况多种多样，首先它的数据源就可能是文件、控制台、服务器等，它的单位可能是按字节、按字符、按行等。为了涵盖所有的可能，java类库中创建了大量的类，如此多的类让我们在使用时感觉有点难以选择。

I/O流按数据单位可分为字节流(InputStream/OutputStream)和字符流(Reader/Writer)，其它的类主要是从这四个抽象类中派生出来的。除此之外，还有一个独立于这两种流之外的类——RamdomAccessFile。

一、字节流(InputStream/OutputStream)

1.InputStream

每一种数据源都有相应的InputStream的子类：

(1)字节数组——ByteArrayInputStream：

它能将字节数组转化为输入流，下面为简单示例：

    public static void main(String[] args) {
        byte[] strArr={11,22,45,65};
        ByteArrayInputStream bais=new ByteArrayInputStream(strArr);
        int b;
        while((b=bais.read())!=-1){
            System.out.println(b);
        }
        /*
        output:
            11
            22
            45
            65
        */
    }

(3)文件——FileInputStream：

将文件转换为输入流，下面为简单的文本输出操作示例：

    public static void main(String[] args) throws FileNotFoundException {
        File file=new File("D:/Test/log.txt");
        FileInputStream fis=new FileInputStream(file);
        byte[] buffer=new byte[8*1024];
        int len;
        try {
            while((len=fis.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

管道——PipedInputStream：

需和PipeOutputStream搭配使用，下面是一个简单的示例：

public class PipedStreamTest {
    public static void main(String[] args) {
        Sender sender = new Sender();
        Receiver receiver = new Receiver();

        PipedOutputStream outStream = sender.getOutStream();
        PipedInputStream inStream = receiver.getInStream();

        try {
            inStream.connect(outStream); // 与outStream.connect(inStream);等效，二选其一
        } catch (Exception e) {
            e.printStackTrace();
        }

        sender.start();
        receiver.start();
    }
}

class Sender extends Thread {

    private PipedOutputStream outStream = new PipedOutputStream();

    public PipedOutputStream getOutStream() {
        return outStream;
    }

    public void run() {
        Scanner in = new Scanner(System.in);
        while (true) {
            String str = in.nextLine();
            if (str.equals("exit")) {
                break;
            }
            try {
                System.out.println("send message: " + str);
                outStream.write(str.getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            if (outStream != null)
                outStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Sender close");
    }
}

class Receiver extends Thread {
    private PipedInputStream inStream = new PipedInputStream();

    public PipedInputStream getInStream() {
        return inStream;
    }

    public void run() {
        byte[] buffer = new byte[1024];
        int len;
        try {
            while ((len = inStream.read(buffer)) != -1) {
                System.out.println("receive message: " + new String(buffer, 0, len));
                System.out.println("-------------------------");
            }
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        try {
            if (inStream != null)
                inStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Receiver closed");
        System.out.println("end");
    }
}

对于上面的例子运行后在控制台进行测试：

hello  //Console input
send message: hello
receive message: hello
-------------------------
world //Console input
send message: world
receive message: world
-------------------------
exit
Sender close
Receiver closed
end

其它的InputStream流集合——SequenceInputStream

将两个InputStream转化成一个InputStream：

        byte[] bytes1={12,34};
        byte[] bytes2={56,78};
        ByteArrayInputStream bais1=new ByteArrayInputStream(bytes1);
        ByteArrayInputStream bais2=new ByteArrayInputStream(bytes2);
        SequenceInputStream sis=new SequenceInputStream(bais1,bais2);
        int b;
        try {
            while((b=sis.read())!=-1){
                System.out.print(b+"; ");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        /*
        output:
            12; 34; 56; 78;
        */    

SequenceInputStream可以将不同类型的InputStream转化为一个InputStream，当InputStream大于两个的时候，需要用Vector类：

    public static void main(String[] args) throws IOException {
        InputStream is1=new ByteArrayInputStream(new byte[]{111,112,113});
        InputStream is2=new FileInputStream("D:/log.txt");
        InputStream is3=new URL("http://www.baidu.com").openStream();
        Vector<InputStream> v=new Vector<>();
        v.add(is1);
        v.add(is2);
        v.add(is3);
        SequenceInputStream is=new SequenceInputStream(v.elements());
        byte[] buffer=new byte[1024];
        int len;
        int count=0;
        while((len=is.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
            if(++count%100==0){
                break;
            }
        }
        is.close();
    }

……

2.OutputStream

(1)ByteArrayOutputStream。在内存中创建缓冲区，将写入的数据保存在缓冲区中。

    public static void main(String[] args) throws FileNotFoundException {
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        baos.write(12);
        baos.write(23);
        baos.write(34);
        byte[] bytes=baos.toByteArray();
        System.out.println(Arrays.toString(bytes));
        /*
        output:
            [12, 23, 34]
        */
    }

(2)FileOutputStream。可将信息写入文件，可选择覆盖或在末尾添加。

    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("D:/Test/log.txt",true);
        fos.write("我是好人".getBytes());
        fos.close();
    }

(3)PipeOutputSream。需和PipeOutputStream搭配使用，上文中已经提到，这里就不再叙述。

……

---

上面所提及的几种类型都是InputStream/OutputStream的直接子类，是进行I/O流操作的几种基本类型，但是对于写入和读取的数据类型限制太大，比如如果我们如果想要直接写入float或long类型的数据，就无法完成。

要实现这个需求，需要对InputStream和OutputStream进行封装处理，这里就得提一下两个装饰器类：FilterInputStream和FiltOutputStream。

FilterInputStream和FiltOutputStream分别是InputStream和OutputStream的子类，它们增加了I/O流操作的灵活性，但同时也增加了代码的复杂性。

这两个类是I/O操作的基础类，通常我们不会直接使用，而是用功能更加具体完善的它们的子类。

1.FilterInputStream

FilterInputStream的常见子类有DataInputStream、BufferedInputStream。

(1)DataInputStream

与DataOutputStream搭配使用，主要特点是可以读写基本类型数据，不过需要读写对应。

    public static void main(String[] args) throws IOException {
        String path="D:/test.txt";
        DataOutputStream dos=new DataOutputStream(new FileOutputStream(path));
        DataInputStream dis=new DataInputStream(new FileInputStream(path));
        dos.writeInt(110);
        dos.writeUTF("我是好人");
        System.out.println(dis.readInt());
        System.out.println(dis.readUTF());
        dis.close();
        dos.close();
    }

(2)BufferedInputStream

使用了缓冲区，避免每次读取时都进行实际操作，可指定缓冲区大小，默认为8192byte。每次读取时，首先会从缓冲区获取，若缓冲区中读取完了则从数据源输入流中重新获取数据至缓冲区中。

下面为读取操作的源码：

    private int read1(byte[] b, int off, int len) throws IOException {
        int avail = count - pos;
        if (avail <= 0) {
            /* If the requested length is at least as large as the buffer, and
               if there is no mark/reset activity, do not bother to copy the
               bytes into the local buffer.  In this way buffered streams will
               cascade harmlessly. */
            if (len >= getBufIfOpen().length && markpos < 0) {
                return getInIfOpen().read(b, off, len);
            }
            fill();
            avail = count - pos;
            if (avail <= 0) return -1;
        }
        int cnt = (avail < len) ? avail : len;
        System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
        pos += cnt;
        return cnt;
    }

值得注意的是当读取的长度大于缓冲区的长度，将直接调用数据源输入流的read方法。

缓冲是用来减少来自输入设备的单独读取操作数的数量的，因此缓冲有时并不必要，当例如数据块足够大的时候，不需要使用缓冲，如文件的复制就不需要缓冲。

2.FilterOutputStream

FilterOutputStream常见的子类有DataOutputStream、BufferedOutputStream。

(1)DataOutputStream

需和DataInputStream搭配使用，上文中已经提及，此处不再叙述。

(2)BufferedOutputStream

BufferedOutputStream在输出的时候会先将数据写入缓冲区，满足一定条件后再将缓冲区中的数据输出，所以当我们完成输出操作时，需调用flush方法将缓冲区中的数据输出。

下面为输出操作源码：

    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            /* If the request length exceeds the size of the output buffer,
               flush the output buffer and then write the data directly.
               In this way buffered streams will cascade harmlessly. */
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }

当输出的长度大于等于缓冲长度时，先将缓冲区中的数据输出，在讲待输出数据直接输出，不经过缓冲区这个过程。

当输出的长度小于缓冲区长度但又大于缓冲区剩余长度时，会先将缓冲区的数据输出，再将待输出数据写入缓冲区。

当输出的长度小于缓冲区长度时，数据会写入缓冲区。

jdk1.8中FilterOutputStream的close方法源码如下：

    public void close() throws IOException {
        try (OutputStream ostream = out) {
            flush();
        }
    }

这是一种新的实现机制，在try语句结束后，会自动调用Closeable.close()方法。close方法中调用的flush方法，避免了我们忘记调用flush方法时的输出遗漏，虽然如此，但我们最好还是自己调用flush方法。

---

二、字符流(Reader/Writer)

InputStream和OutputStream仅支持8位字节流，不能很好地支持16位的Unicode字符，Reader和Writer支持Unicode，实现了国际化。

对于纯文本通常使用字符流，对于其它的例如视频、音频和图片等文件通常使用字节流。

1.InputStreamReader&OutputStreamWriter

有些时候，我们需要将字节流和字符流结合起来使用，因此需要适配器，InputStreamReader和OutputStreamWriter这两个类能够将字节流转化为字符流，同时可以设置字符编码。

OutPutStreamWriter使用的缓冲区，所以输入完成后需要调用flush方法。

2.FileReader&FileWriter

这两个类分别是InputStreamReader和OutputStreamWriter的子类，它们只是简单地增加了文件和文件名转化为流的构造方法。

3.BufferedReader&BufferedWriter

这两个类是文本读写中较为常见，其内部结构与BufferedInputStream&BufferedOutputStream类似。

比较特殊的是输出时的newLine方法可换行，读取时的readLine方法可实现一行一行的读取。

下面为这两个类使用的简单示例：

    public static void main(String[] args) throws IOException {
        String filename = "D:/Test/log.txt";
        String charset = "utf-8";
        String[] msgArr={"I'm line 1","I'm line 2","I'm line 3","I'm line 4","I'm line 5"};

        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename), charset));
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), charset));
        for (String string : msgArr) {
            writer.write(string);
            writer.newLine();
        }
        writer.flush();

        StringBuilder sb=new StringBuilder();
        String line;
        while((line=reader.readLine())!=null){
            sb.append(line+"\n");
        }
        writer.close();
        reader.close();
        System.out.println(sb.toString());
        /*
        output:
            I'm line 1
            I'm line 2
            I'm line 3
            I'm line 4
            I'm line 5
        */
    }

4.PrintWriter

这个类最大的特点是有很多的构造方法，方便我们面对各种情况是的使用，它还增加了各种类型数据输出，包括long、float、double等。

它的一个构造方法如下：

    public PrintWriter(Writer out,
                       boolean autoFlush) {
        super(out);
        this.out = out;
        this.autoFlush = autoFlush;
        lineSeparator = java.security.AccessController.doPrivileged(
            new sun.security.action.GetPropertyAction("line.separator"));
    }

当autoFlush为true的时候，每当调用newLine方法，将自动清空缓冲区，不过newLine是私有方法，需通过println方法调用。

……

---

三、RamdomAccessFile

RamdomAccessFile支持对随机访问文件的读取和写入，常用于多线程下载。

下面来看看RamdomAccessFile几个常用方法：

1. void setLength(long newLength)

此方法可设置文件大小，当文件原来的大小大于设置的大小，将会把文件裁剪为设置大小。

2. int length()

返回文件的大小。

3. long getFilePointer()

返回指针的位置。

4. void seek(long pos)

移动指针至pos位置。

下面为一个简单的示例：

import java.io.IOException;
import java.io.RandomAccessFile;

public class Test {

    public static final String CHARSET = "utf-8";
    public static final String[] MSG_ARR = { "1床前明月光，", "12疑是地上霜，", "123举头望明月，", "1234低头思故乡。" };
    public static final int[] POS_ARR = new int[5];
    public static final String FILENAME = "D:/log.txt";

    public static void main(String[] args) throws IOException, InterruptedException {
        POS_ARR[0] = 0;
        int count = 0;
        for (int i = 0; i < 4; i++) {
            count += MSG_ARR[i].getBytes(CHARSET).length;
            POS_ARR[i + 1] = count;
        }
        RandomAccessFile raf = new RandomAccessFile(FILENAME, "rw");
        raf.setLength(POS_ARR[4]);
        for (int i = 0; i < 4; i++) {
            RafThread rt = new RafThread(FILENAME, POS_ARR[i], MSG_ARR[i]);
            rt.start();
        }

        Thread.sleep(100);

        String line;
        while ((line = raf.readLine()) != null) {
            System.out.println(new String(line.getBytes("ISO-8859-1"), CHARSET));
        }
        raf.close();
        /*
        outtput:
            1床前明月光，12疑是地上霜，123举头望明月，1234低头思故乡。
        */
    }

}

class RafThread extends Thread {

    private String filename;
    private int po;
    private String msg;

    public RafThread(String filename, int po, String msg) {
        this.filename = filename;
        this.po = po;
        this.msg = msg;
    }

    @Override
    public void run() {
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile(filename, "rw");
            raf.seek(po);
            raf.write(msg.getBytes("utf-8"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf != null) {
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

四、新I/O

jdk1.4引入了新的I/Ol类库java.nio，而旧的I/O也用新I/O重新实现过，所以就算不显示使用，相对旧I/O效率也有了提升。

由于没有什么使用经验，留待以后再说……