Java NIO核心概念及基本读写

时间 2019-11-12

标签 java nio 核心概念基本读写栏目 Java 繁體版

原文原文链接

面向流的I/O系统一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据建立过滤器很是容易。连接几个过滤器，以便每一个过滤器只负责单个复杂处理机制的一部分，这样也是相对简单的。不利的一面是，面向流的I/O一般至关慢。
NIO与原来的I/O有一样的做用和目的，可是它使用块I/O的处理方式。每个操做都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。可是面向块的I/O缺乏一些面向流的I/O所具备的优雅性和简单性。 java

/** 
 * 使用IO读取指定文件的前1024个字节的内容。 
 * @param file 指定文件名称。 
 * @throws java.io.IOException IO异常。 
 */  
public void ioRead(String file) throws IOException {  
    FileInputStream in = new FileInputStream(file);  
    byte[] b = new byte[1024];  
    in.read(b);  
    System.out.println(new String(b));  
}  
  
/** 
 * 使用NIO读取指定文件的前1024个字节的内容。 
 * @param file 指定文件名称。 
 * @throws java.io.IOException IO异常。 
 */  
public void nioRead(String file) throws IOException {  
    FileInputStream in = new FileInputStream(file);  
    FileChannel channel = in.getChannel();  
  
    ByteBuffer buffer = ByteBuffer.allocate(1024);  
    channel.read(buffer);  
    byte[] b = buffer.array();  
    System.out.println(new String(b));  
}

从上面的例子中能够看出，NIO以通道Channel和缓冲区Buffer为基础来实现面向块的IO数据处理。下面将讨论并学习NIO 库的核心概念以及从高级的特性到底层编程细节的几乎全部方面。sql

2.    核心概念：通道和缓冲区
   1)    概述：
   通道和缓冲区是NIO中的核心对象，几乎在每个I/O操做中都要使用它们。
   通道Channel是对原I/O包中的流的模拟。到任何目的地(或来自任何地方)的全部数据都必须经过一个Channel对象。
   缓冲区Buffer实质上是一个容器对象。发送给一个通道的全部对象都必须首先放到缓冲区中；一样地，从通道中读取的任何数据都要读到缓冲区中。

2)    缓冲区：
   Buffer是一个容器对象，它包含一些要写入或者刚读出的数据。在NIO中加入Buffer对象，体现了新库与原I/O的一个重要区别。在面向流的I/O中，您将数据直接写入或者将数据直接读到Stream对象中。
   在NIO库中，全部数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任什么时候候访问NIO中的数据，您都是将它放到缓冲区中。
   缓冲区实质上是一个数组。一般它是一个字节数组，可是也可使用其余种类的数组。可是一个缓冲区不只仅是一个数组。缓冲区提供了对数据的结构化访问，并且还能够跟踪系统的读/写进程。
   最经常使用的缓冲区类型是ByteBuffer。一个ByteBuffer能够在其底层字节数组上进行get/set操做(即字节的获取和设置)。
   ByteBuffer不是NIO中惟一的缓冲区类型。事实上，对于每一种基本Java类型都有一种缓冲区类型：
   ByteBuffer
   CharBuffer
   ShortBuffer
   IntBuffer
   LongBuffer
   FloatBuffer
   DoubleBuffer
   每个Buffer类都是Buffer接口的一个实例。除了ByteBuffer，每个Buffer类都有彻底同样的操做，只是它们所处理的数据类型不同。由于大多数标准I/O操做都使用ByteBuffer，因此它具备全部共享的缓冲区操做以及一些特有的操做。编程

/**
 * 使用 float 缓冲区。
 * @since 1.5
 */
public class UseFloatBuffer {

    public static void main(String[] args) {
        // 分配一个容量为10的新的 float 缓冲区
        FloatBuffer buffer = FloatBuffer.allocate(10);
        for (int i = 0; i < buffer.capacity(); i++) {
            float f = (float) Math.sin((((float) i) / 10) * (2 * Math.PI));
            buffer.put(f);
        }
        // 反转此缓冲区
        buffer.flip();

        // 告知在当前位置和限制之间是否有元素
        while (buffer.hasRemaining()) {
            float f = buffer.get();
            System.out.println(f);
        }
    }
}

   3)   通道：
   Channel是对原I/O包中的流的模拟，能够经过它读取和写入数据。拿NIO与原来的I/O作个比较，通道就像是流。
   正如前面提到的，全部数据都经过Buffer对象来处理。您永远不会将字节直接写入通道中，相反，您是将数据写入包含一个或者多个字节的缓冲区。一样，您不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。
通道与流的不一样之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是InputStream或者OutputStream的子类)，而通道能够用于读、写或者同时用于读写。
   由于它们是双向的，因此通道能够比流更好地反映底层操做系统的真实状况。特别是在UNIX模型中，底层操做系统通道是双向的。数组

4.   从理论到实践：NIO中的读和写
   1)   概述：
   读和写是I/O的基本过程。从一个通道中读取很简单：只需建立一个缓冲区，而后让通道将数据读到这个缓冲区中。写入也至关简单：建立一个缓冲区，用数据填充它，而后让通道用这些数据来执行写入操做。

   2)   从文件中读取：
若是使用原来的I/O，那么咱们只需建立一个FileInputStream并从它那里读取。而在NIO中，状况稍有不一样：咱们首先从FileInputStream获取一个FileChannel对象，而后使用这个通道来读取数据。
   在NIO系统中，任什么时候候执行一个读操做，您都是从通道中读取，可是您不是直接从通道读取。由于全部数据最终都驻留在缓冲区中，因此您是从通道读到缓冲区中。
   所以读取文件涉及三个步骤：
   (1) 从FileInputStream获取Channel。
   (2) 建立Buffer。
   (3) 将数据从Channel读到Buffer 中。
   如今，让咱们看一下这个过程。学习

// 第一步是获取通道。咱们从 FileInputStream 获取通道： 
FileInputStream fin = new FileInputStream( "readandshow.txt" );
FileChannel fc = fin.getChannel();
// 下一步是建立缓冲区： 
ByteBuffer buffer = ByteBuffer.allocate( 1024 );
// 最后，须要将数据从通道读到缓冲区中： 
fc.read( buffer );

3) 写入文件：
在 NIO 中写入文件相似于从文件中读取。spa

// 首先从 FileOutputStream 获取一个通道： 
FileOutputStream fout = new FileOutputStream( "writesomebytes.txt" );
FileChannel fc = fout.getChannel();
// 下一步是建立一个缓冲区并在其中放入一些数据，这里，用message来表示一个持有数据的数组。 
ByteBuffer buffer = ByteBuffer.allocate( 1024 );
for (int i=0; i<message.length; ++i) {
     buffer.put( message[i] );
}
buffer.flip();
// 最后一步是写入缓冲区中： 
fc.write( buffer );

注意在这里一样不须要告诉通道要写入多数据。缓冲区的内部统计机制会跟踪它包含多少数据以及还有多少数据要写入。操作系统

4) 读写结合：
下面的示例将展现使用读写结合，将一个文件的全部内容拷贝到另外一个文件中。code

/**
 * 将一个文件的全部内容拷贝到另外一个文件中。
 * 
 * CopyFile.java 执行三个基本操做：
 * 首先建立一个 Buffer，而后从源文件中将数据读到这个缓冲区中，而后将缓冲区写入目标文件。
 * 程序不断重复 — 读、写、读、写 — 直到源文件结束。
 * 
 */
public class CopyFile {

    public static void main(String[] args) throws Exception {
        String infile = "C:\\copy.sql";
        String outfile = "C:\\copy.txt";

        // 获取源文件和目标文件的输入输出流
        FileInputStream fin = new FileInputStream(infile);
        FileOutputStream fout = new FileOutputStream(outfile);

        // 获取输入输出通道
        FileChannel fcin = fin.getChannel();
        FileChannel fcout = fout.getChannel();

        // 建立缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (true) {
            // clear方法重设缓冲区，使它能够接受读入的数据
            buffer.clear();

            // 从输入通道中将数据读到缓冲区
            int r = fcin.read(buffer);

            // read方法返回读取的字节数，可能为零，若是该通道已到达流的末尾，则返回-1
            if (r == -1) {
                break;
            }

            // flip方法让缓冲区能够将新读入的数据写入另外一个通道
            buffer.flip();

            // 从输出通道中将数据写入缓冲区
            fcout.write(buffer);
        }
    }
}