NIO流—理解Buffer、Channel概念和NIO的读写操作

NIO流与IO流的区别

面向流与面向块

• IO流是每次处理一个或多个字节，效率很慢（字符流处理的也是字节，只是对字节进行编码和解码处理）。
• NIO流是以数据块为单位来处理，缓冲区就是用于读写的数据块。缓冲区的IO操作是由底层操作系统实现的，效率很快。

阻塞式与非阻塞式

• IO流是阻塞式的，使用read()与write()方法时，执行期间只能等待该方法完成。
• NIO流是非阻塞式的，执行读写时依然可以做别的事情，不会阻塞线程，提高资源利用率，NIO流的Selector就是非阻塞式的。

NIO加入了Selector（选择器）

• Selector可以让一个线程监视多个Channel，只需要一个线程处理所有管道，减少线程开销。

nio流的相关类都放在java.nio包中，大体如下：

• java.nio 包：包含各种类型的Buffer(缓冲区)
• java.nio.channels包：包含各种Channel(管道) 和Selector(选择器)
• java.nio.charset包:包含各种处理字符集的类 

Buffer（缓冲区）

• 常用ByteBuffer 和 CharBuffer，还有一系列值类型Buffer，可以应用于不同类型。
• 所有Buffer都是抽象类，无法直接实例化。创建缓冲区要调用XxxBuffer allocate()，参数是缓冲区容量。
• 缓冲区数据存放在内存中，读写效率高。缓冲区有记录指针，能改变读写的起始点，根据不同需求，灵活处理数据。

Buffer参数说明

• capacity(容量)：缓冲区支持的最大容量。
• position(记录指针位置)：是缓冲区读写数据的起始点，初始值为0。position随着数据的加入而改变，例如读取2个数据到Buffer中，则position = 2。
• limit(界限)：是缓冲区读写数据的终止点，limit之后的区域无法访问。
• mark(标记)：mark在0~position之间，设置该值就会把position移动到mark处。

Buffer的常用方法：

• flip()：确定缓冲区数据的起始点和终止点，为输出数据做准备(即写入通道)。此时：limit = position，position = 0。
• clear()：缓冲区初始化，准备再次接收新数据到缓冲区。position = 0，limit = capacity。
• hasRemaining()：判断postion到limit之间是否还有元素。
• rewind()：postion设为0，则mark值无效。
• limit(int newLt)：设置界限值，并返回一个缓冲区，该缓冲区的界限和limit()设置的一样。
• get()和put()：获取元素和存放元素。使用clear()之后，无法直接使用get()获取元素，需要使用get(int index)根据索引值来获取相应元素。

图片理解Buffer读写数据的流程变化

     

Channel（通道）

Channel通过Buffer(缓冲区)进行读写操作。read()表示读取通道数据到缓冲区，write()表示把缓冲区数据写入到通道。

Channel需要节点流作为创建基础，例如FileInputStream和FileOutputStream()的getChannel()。RandomAccessFile也能创建文件通道，支持读写模式。通过IO流创建的通道是单向的，使用RandomAccessFile创建的通道支持双向。

通道可以异步读写，异步读写表示通道执行读写操作时，也能做别的事情，解决线程阻塞。如果使用文件管道（FileChannel），建议用RandomAccessFile来创建管道，因为该类支持读写模式以及有大量处理文件的方法。

Channel实现类

FileChannel //读写文件通道
SocketChannel //通过TCP读写网络数据通道
ServerSocketChannel //监听多个TCP连接
DataChannel //通过UDP读写网络数据通道
Pipe.SinkChannel、Pipe.SourceChannel //线程通信管道传输数据

Channel常用方法

read()  //从Buffer中读取数据。
write() //写入数据到Buffer中。
map()   //把管道中部分数据或者全部数据映射成MappedByteBuffer，本质也是一个ByteBuffer。map()方法参数（读写模式，映射起始位置，数据长度）。
force() //强制将此通道的元数据也写入包含该文件的存储设备。

charset（字符集）

• 包含了字节和 Unicode 字符之间转换的 charset，还定义了用于创建解码器和编码器以及获取与 charset 关联的各种方法。
• CharsetDecoder(解码器)：把字节转成字符，例如查看文本数据，需要转成字符才能查看，如果是字节，就看不懂了。
• CharsetEncoder(编码器)：把字符转成字节，才能被计算机理解。 因为字节是计算机最小的存储单位，所以Channel的IO操作都与ByteBuffer有关。
• 解码器和编码器都不能直接创建，需要一个Charset对象来创建对应的解码器和编码器。

Charset的常用方法

forName()：根据传入的字符集获得对应的字符集对象。
defaultCharset()：获得当前使用的默认字符集。
availableCharsets()：获得所有有效的字符集。
当使用nio来获取文件内容时，如果是文本数据，那么需要进行转码，才能查看正确内容，这就需要解码器。 如果要把字符数据写入文件，需要将CharBuffer转码成ByteBuffer，这就需要编码器。

Buffer实例

        //创建字节缓冲区，容量1024
        ByteBuffer buff = ByteBuffer.allocate(1024);
        System.out.println(buff.position());//读写起始点
        System.out.println(buff.limit());//界限位置
        //字节缓冲区放入3个int数值
        buff.putInt(10);
        buff.putInt(15);
        buff.putInt(20);
        System.out.println(buff.position());// 放入数据后，position:12
        //切换读取模式，方便输出数据
        buff.flip();
        System.out.println("切换写模式后，position———limit，" + buff.position() + "———" + buff.limit());
        //切换写入模式，方便获取数据
        buff.clear();
        System.out.println("切换读模式后，position———limit，" + buff.position() + "———" + buff.limit());

上面代码中，Buffer的allocate(int capacity)用于创建缓冲区。position()与limit()分别获取当前缓冲区的读写点与终止点。使用put()放入数据，put()有一系列方法放入不同数类型据。因为是字节缓冲区，而int数值是占4字节，所以position是12。flip()和clear()使用之后，会对读写点和终止点进行改变。当然，还有一系列方法，可自己实验。

创建Channel

        File f1 = new File("D:\reviewIO\ChannelDemo.txt");
        File f2 = new File("D:\reviewIO\ChannelDemo2.txt");

        //文件输入/输出流来创建通道
        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);
        FileChannel inChannel = fis.getChannel();//读取通道
        FileChannel outChannel = fos.getChannel();//写入通道
        //使用RandomAccessFile来创建FileChannel
        FileChannel rafChannel = new RandomAccessFile(f1,"rw").getChannel();
        FileChannel rafChannel2 = new RandomAccessFile(f2,"rw").getChannel();

上面代码中，使用输入/输出流来分别创建了文件通道，虽然通道是双向的。但输入流的通道只能用于读取数据到缓冲区，输出流的通道用于把缓冲区数据写入通道。使用RandomAccessFile类也可以创建通道，RandomAccessFile可以设为读写模式。

使用Channel的内存映射

        File f1 = new File("D:\reviewIO\ChannelDemoF1.txt");
        File f2 = new File("D:\reviewIO\ChannelDemoF2.txt");
        //使用RandomAccessFile来创建FileChannel
        FileChannel inChannel = new RandomAccessFile(f1,"rw").getChannel();
        FileChannel outChannel = new RandomAccessFile(f2,"rw").getChannel();
        
        //把rafChannel通道的全部数据映射成ByteBuffer
        MappedByteBuffer mapBuff = inChannel.map(MapMode.READ_ONLY, 0, f1.length());

上面代码中，Channel直接把通道中全部数据映射成ByteBuffer，使用内存映射可以大幅度提高文件拷贝性能，后面会进行比较。也可以使用Buffer的allocate()来自由分配缓冲区容量，看个人需求来。

使用NIO读取文件数据

        File file = new File("D:\reviewIO\word.txt");
        //以只读模式来创建通道
        FileChannel inChannel = new RandomAccessFile(file,"r").getChannel();
        //创建字节缓冲区
        ByteBuffer bytebuf = ByteBuffer.allocate(1024);    
        //默认字符集创建解码器
        CharsetDecoder decoder = Charset.defaultCharset().newDecoder();
        
        while((inChannel.read(bytebuf)) != -1) {//读取通道数据到缓冲区中,非-1就代表有数据
            //确定缓冲区数据的起点和终点
            bytebuf.flip();
            //对bytebuf进行解码，避免乱码
            CharBuffer decode = decoder.decode(bytebuf);
            System.out.println(decode.toString());
            //清空缓冲区，再次放入数据
            bytebuf.clear();
        }    

使用nio流读取文件要注意flip()和clear()方法，flip()是确定缓冲区数据的起点和终点位置，避免访问到limit()之后的区域。clear()是把缓冲区初始化，方便再次写入数据到缓冲区。因为是ByteBuffer，所以无法直接显示文本内容，需要使用解码器来转码成字符缓冲区。

nio流写入字符串到文件中

        Scanner sc = new Scanner(System.in);
        File file = new File("D:\reviewIO\writeNio.java");
        if(!file.exists()) 
            file.createNewFile();
        //RandomAccessFile创建通道，是读写模式
        FileChannel inChannel = new RandomAccessFile(file,"rw").getChannel();
        //创建字符缓冲区,容量1024
        CharBuffer charBuf = CharBuffer.allocate(1024);    
        //使用默认字符集创建编码器
        CharsetEncoder encoder = Charset.defaultCharset().newEncoder();
        String str = null;
        while(!(str = sc.next()).equals("end")) {
            //往缓冲区中写入数据
            charBuf.put(str+"
");
            //为输出缓冲区数据做准备
            charBuf.flip();
            //对缓冲区进行编码，避免乱码
            ByteBuffer bb = encoder.encode(charBuf);
            //把缓冲区数据写入通道
            inChannel.write(bb);
            //Buffer初始化,为下一次读取数据做准备
            charBuf.clear();
        }

上面代码实现从键盘输入数据，然后写入指定文件中。因为缓冲区是字符类型，而通道的读写操作都是使用byteBuffer，所以要使用编码器将CharBuffer转码成ByteBuffer，才能往通道中写入数据。

使用内存映射拷贝文件

    public static void copyLargeFile(String srcPath, String destPath) throws IOException {
        File src = new File(srcPath);//源文件
        File dest = new File(destPath);//拷贝的文件
        FileChannel fcin = null;//文件输入通道
        FileChannel fcout = null;//文件输出通道
        if(!src.isFile()) {
             System.err.println("源路径指向的不是文件");
             return;
        }
        if(!src.exists() || !dest.exists()) {
            System.err.println("源文件或者拷贝文件路径不存在，请检查！");
            return;
        }
        fcin = new FileInputStream(src).getChannel();
        fcout = new FileOutputStream(dest).getChannel();
        //把文件输入通道数据全部映射成ByteBuffer
        MappedByteBuffer buf = fcin.map(FileChannel.MapMode.READ_ONLY, 0, fcin.size());                
        //fcout写入数据，数据源是buf缓冲区
        fcout.write(buf);
        //buf初始化，准备再次接收数据
        buf.clear();
    }

NIO拷贝大型文件性能很好，如果是拷贝小文件那和IO流差别不大。所以那个体系用得爽就用那个。

自定义缓冲区分批次拷贝文件

    public static void copyLargeFile2(String srcPath, String destPath) throws IOException {
        File src = new File(srcPath);//源文件
        File dest = new File(destPath);//拷贝文件路径
        FileChannel fcin = null;//文件输入通道
        FileChannel fcout = null;//文件输出通道
        if(!src.isFile()) {
             System.err.println("源路径指向的不是文件");
             return;
        }
        if(!src.exists() || !dest.exists()) {
            System.err.println("源文件或者拷贝文件路径不存在，请检查！");
            return;
        }
        fcin = new FileInputStream(src).getChannel();
        fcout = new FileOutputStream(dest).getChannel();
        //容量1024缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        while((fcin.read(buf)) != -1) {//读取管道数据到缓冲区中，为1则结束
            //确定缓冲区数据的起点和终点
            buf.flip();
            //fcout写入数据，数据源是buf缓冲区
            fcout.write(buf);
            //buf初始化，准备再次接收数据
            buf.clear();
        }        
    }

使用自定义缓冲区可以避免一次性写入大量数据到内存中。还有如果拷贝的是文本数据，也建议使用ByteBuffer。不要使用CharBuffer作为缓冲区，省略编码步骤。如果是读取文本数据并且显示的话还是需要解码器转码成字符缓冲区。