本文参考了众多文章，很多文章的源连接已经无法找到了，如果本文引用了您的文章，请联系我，我会在具体的位置加入您的连接地址，同时本文NIO部分大都引用 NIO详解 这篇文章。

IO流

java.io包中的类对应两类流，一类流直接从指定的位置（如磁盘文件或内存区域）读或写，这类流称为节点流，其它的流则称为处理流。处理输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，处理输出流的原理也类似。
java中的流分为输入流和输出流，分别表示流中的字节数据两种流动方向。（以程序作为参考物，即相对于程序而言，是输入还是输出）

字节流与字符流

字节流

如果操作文件，图片，音频等文件，采用字节流比较合适，字节流从本质上来说，可以解决一切的IO操作。

InputStream 与 outputStream

InputStream 是所有字节输入流的祖先，而 OutputStream 是所有字节输出流的祖先。

字节节点流

• FileInputStream 和 FileOutputStream （用于读写磁盘中的数据）
  
  • 可以操作任意类型的文件，第一个类的源端和第二个类的目的端都是磁盘文件，它们的构造方法允许通过文件的路径名来构造相应的流。如：
    
    • FileInputStream infile = new FileInputStream(“myfile.dat”);
    • FileOutputStream outfile = new FileOutputStream(“results.dat”);
  • 要注意的是，构造FileInputStream, 对应的文件必须存在并且是可读的，而构造FileOutputStream时，如输出文件已存在，则必须是可覆盖的。
  • 在数据流的处理过程中，有两种情况。
    
    • 以单个字节的形式读写文件
    • 以数据块的形式读写文件
  • FileInputStream的读：
    
    • public native int read() throws IOException;
    • private native int readBytes(byte b[], int off, int len) throws IOException;
  • FileOutputStream的写：
    
    • public native void write(int b) throws IOException;
    • private native void writeBytes(byte b[], int off, int len) throws IOException;
• PipedInputStream 与 PipedOutputStream （用于线程之间的通信）
  
  • 用于在应用程序中创建管道通信.一个 PipedInputStream 实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道. PipedOutputStream 可以向管道中写入数据, PipedIntputStream 可以读取 PipedOutputStream 向管道中写入的数据.这两个类主要用来完成线程之间的通信.一个线程的 PipedInputStream 对象能够从另外一个线程的PipedOutputStream对象中读取数据.
    
  • ByteArrayInputStream与ByteArrayOutputStream
    
    • ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。
    • 关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。
    • ByteArrayOutputStream：此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray()和 toString()获取数据。
    • 关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何IOException。ByteArrayOutputStream 是用来缓存数据的，向它的内部缓冲区写入数据，缓冲区自动增长，当写入完成时可以从中提取数据。由于这个原因，ByteArrayOutputStream 常用于存储数据以用于一次写入。

字节处理流

• BufferedInputStream 和 BufferedOutputStream （缓冲）
  
  • 了解这两个类之前，我们有必要知道不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！而BufferedInputStream和BufferedOutputStream类就是实现了缓冲功能的输入流/输出流。
  • BufferedInputStream 内部有一个缓冲区，默认大小为8kb，每次调用 read 方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快，所以BufferedInputStream的效率很高！
  • 同时正因为实现了缓冲功能，所以要注意在使用 BufferedOutputStream 写完数据后，要调用flush()方法或close()方法，强行将缓冲区中的数据写出。否则可能无法写出数据。
• DataInputStream 和 DataOutputStream （网络数据传输）
  
  • 这两个类创建的对象分别被称为数据输入流和数据输出流。这是很有用的两个流，它们允许程序按与机器无关的风格读写Java数据。所以比较适合于网络上的数据传输。常以其它流如 InputStream 或 OutputStream 作为它们的输入或输出。
  • DataOutputStream：数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后应用程序可以使用数据输入流将数据读入。
  • DataOutputStream：数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。
  • 若想通过这两个类去读取汉字，则可以使用 readUTF/writeUTF方法，该方法默认是UTF-8格式
• ObjectInputStream 与 ObjectOutputStream （序列化流）
  
  • 可用于输入流中读取对象类数据和将对象类型的数据写入到底层输入流，使用对象流需要实现Serializable接口，否则会报错。而若用transient关键字修饰成员变量，不写入该成员变量，若是引用类型的成员变量为null，值类型的成员变量为0。
  • 可以使用两个流来完成对象的深复制
• SequenceInputStream （连接流）
  
  • SequenceInputStream 类允许连接多个 InputStream 对象。SequenceInputStream 对象的构造与其他所有 InputStream 对象都不同。SequenceInputStream 构造函数使用一对InputStream 对象或 InputStream 对象的一个 Enumeration 对象作为参数
  • 在操作上，该类从第1个InputStream对象进行读取，直到读取完全部内容，然后切换到第2个InputStream对象。对于使用Enumeration对象的情况，该类将持续读取所有InputStream对象中的内容，直到到达最后一个InputStream对象的末尾为止。当到达每个文件的末尾时，与之关联的流就会被关闭。关闭通过SequenceInputStream创建的流，会导致关闭所有未关闭的流。
• PrintStream（打印输出流）
  
  • PrintStream 是打印输出流，它继承于 FilterOutputStream。
  • PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
  • PrintStream 永远不会抛出 IOException ；它产生的 IOException 会被自身的函数所捕获并设置错误标记， 用户可以通过 checkError( ) 返回错误标记，从而查看 PrintStream 内部是否产生了 IOException。
  • PrintStream 提供了自动 flush 和字符集设置功能 。所谓自动 flush，就是往 PrintStream 写入的数据会立刻调用 flush( ) 函数。

字符流

字符流主要是在字节流的基础上，加入了字符的编码格式，因此除非是处理文字等IO操作，尽可能去选择字节流。

Reader与Writer

Reader是所有读取字符串输入流的祖先，而writer是所有输出字符串的祖先。

字符节点流

• FileReader 与 FileWriter （文件字符流）
  
  • FileReader：文件字符输入流、用于将文件内容以字符形式读取出来、一般用于读取字符形式的文件内容、也可以读取字节形式、但是因为 FileReader 内部也是通过传入的参数构造 InputStreamReader 、并且只能使用默认编码、所以我们无法控制编码问题、这样的话就很容易造成乱码。所以读取字节形式的文件还是使用字节流来操作的好、同样在使用此流的时候用 BufferedReader 包装一下、就算冲着 BufferedReader 的 readLine( ) 方法去的也要使用这个包装类、不说他还能提高效率、保护存储介质。
  • FileWriter：文件字符输出流、主要用于将字符写入到指定的打开的文件中、其本质是通过传入的文件名、文件、或者文件描述符来创建 FileOutputStream 、然后使用 OutputStreamWriter 使用默认编码将 FileOutputStream 转换成 Writer（这个Writer就是FileWriter）。如果使用这个类的话、最好使用 BufferedWriter 包装一下、高端大气上档次、低调奢华有内涵！
  • FileWriter、FileReader 以字符的形式对文件进行操作、本质是通过传入的文件名、文件或者文件描述符来创建用于转码或者解码的 InputStreamReader 、 OutputStreamWriter 来将对应的FileInputStream、FileOutputStream转换成字符流来操作、但是最好不要乱用、因为使用这两个类的时候我们不能控制编码问题、不同平台、不同环境下的编码不同、当然非要用的话也可以、但是带来的问题还需要去注意
• PipedReader 与 PipedWriter（字符管道流）
  
  • PipedReader：管道字符输入流、用于读取对应绑定的管道字符输出流写入其内置字符缓存数组 buffer 中的字符、借此来实现线程之间的通信、pipedReader 中专门有两个方法供 pipedWirter 调用、receive(char c)、receive(char[] b, int off, intlen)、使得 pipedWirter 可以将字符或者字符数组写入 pipedReader 的 buffer 中
  • PipedWriter：管道字符输出流、用于将当前线程的指定字符写入到与此线程对应的管道字符输入流中去、所以 PipedReader 、 PipedWriter 必须配套使用、缺一不可。管道字符输出流的本质就是调用 PipedReader 中的方法将字符或者字符数组写入到 PipedWriter 中、这一点是与众不同的地方。所以 PipedWriter 中的方法很少也很简单、主要就是负责将传入的 PipedReader 与本身绑定、配对使用、然后就是调用绑定的 PipedReader 的写入方法、将字符或者字符数组写入到 PipedReader 的缓存字符数组中。
• CharArrayReader 与 CharArrayWriter （字符数组流）
  
  • CharArrayReader：字符数组输入流 CharArrayReader 、与 ByteArrayInputStream 相同、用于将自带的内置缓存字符数组中的字符读取到程序中。与 ByteArrayInputStream 不同的是：当调用 CharArrayReader 的 close 方法是将内置缓存数组 buffer 设为 null 、而且 CharArrayReader 会抛出 IOException 异常（ ensureOpen 方法、即当 buffer 为 null 时则认为 CharArrayReader 关闭）。方法与使用功能与 ByteArrayInputStream 很相似、说白了区别就在于一个是从内置字节数组中读取字节、一个是从内置字符数组中读取字符。有一点是与 ByteArrayInputStream 不同的地方、就是他们的父类的区别、 Reader 比 InputStream 多实现一个 Readable 接口、这个接口要求提供一个方法、是将字符数组读取到指定的缓存数组中、其实完全可以用 read(char[] cbuf, int off, int len) 来代替实现
  • CharArrayWriter：字符数组输出流 CharArrayWriter 、用于将字符写入到内置字符缓存数组char[] buf中、当此数组存放满员时会自动扩容、同样与ByteArrayOutputStream相比他也提供了几个操作buf中字符的方法、可使用 toCharArray() 和 toString() 获取数据、还可使用writeTo(Writer out) 将buf写入到底层流中。同样在此类上调用 close()、flush()无效，不会产生IOException、并且在关闭该流后仍然可以调用此类中的各个方法。

字符处理流

• BufferedReader 和 BufferedWriter （缓冲）
  
  • 这两个类对应的流使用了缓冲，能大大提高输入输出的效率。
  • BufferedReader：从流里面读取文本，通过缓冲的方式提高效率，读取的内容包括字符、数组和行。缓存的大小可以指定，也可以用默认的大小。大部分情况下，默认大小就够了。BufferedReader 中比较重要的方法 readLine( )，可以按行读取。
  • BufferedWriter：将文本写入到字符输出流中，通过缓冲的方式提高效率，以便为单个字符、数组和字符串提供有效的写入。缓冲区大小可指定，或默认大小，大部分情况下，默认大小就够了。
• InputStreamReader 和 OutputStreamWriter
  
  • InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。
  • OutputStreamWriter 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。每次调用 write( ) 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。
  • 编码格式，可在构造函数中初始化
• PrintWriter（字符打印流）
  
  • Java.io.PrintWriter 类打印格式化对象的表示到文本输出流。

NIO

在标准的IO当中，都是基于字节流/字符流进行操作的，而在NIO中则是是基于Channel和Buffer进行操作，其中的Channel的虽然模拟了流的概念，实则大不相同。

区别	Stream	Channel
支持异步	不支持	支持
是否可双向传输数据	不能，只能单向	可以，既可以从通道读取数据，也可以向通道写入数据
是否结合Buffer使用	不	必须结合Buffer使用
性能	较低	较高

核心部分

• Channels
• Buffers
• Selectors

Channels （通道）

基本上，所有的 IO 在NIO 中都从一个 Channel 开始。Java NIO 的通道类似流，但又有些不同：
- 既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。
- 通道可以异步地读写
- 通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。

数据可以从 Channel 读到 Buffer 中，也可以从 Buffer 写到 Channel 中，通道必须结合Buffer使用，不能直接向通道中读/写数据，这里有个图示：

下面是 JAVA NIO 中的一些主要 Channel 的实现：
- FileChannel：从文件中读写数据
- FileInputStream/FileOutputStream/RandomAccessFile 对象中通过 getChannel( ) 得到 FileChannel
- FileChannel 无法设置为非阻塞模式，它总是运行在阻塞模式下
- 用完FileChannel后必须将其关闭
- 有时可能需要在 FileChannel 的某个特定位置进行数据的读/写操作。可以通过调用 position( ) 方法获取 FileChannel 的当前位置。也可以通过调用 position(long pos) 方法设置 FileChannel 的当前位置。
- FileChannel 实例的 size( ) 方法将返回该实例所关联文件的大小
- 可以使用 FileChannel.truncate( ) 方法截取一个文件。截取文件时，文件将中指定长度后面的部分将被删除
- FileChannel.force( ) 方法将通道里尚未写入磁盘的数据强制写到磁盘上。出于性能方面的考虑，操作系统会将数据缓存在内存中，所以无法保证写入到 FileChannel 里的数据一定会即时写到磁盘上。要保证这一点，需要调用 force( ) 方法。force( ) 方法有一个 boolean 类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。
- DatagramChannel 通过UDP读写网络中的数据
- DatagramChannel 是一个能收发 UDP 包的通道。因为 UDP 是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包
- Buffer 通过 receive( ) 方法从 DatagramChannel 接收数据
- 通过 send() 方法从 DatagramChannel 发送数据
- 可以将 DatagramChannel “连接”到网络中的特定地址的。由于 UDP 是无连接的，连接到特定地址并不会像 TCP 通道那样创建一个真正的连接。而是锁住 DatagramChannel ，让其只能从特定地址收发数据
- SocketChannel：能通过TCP读写网络中的数据
- 是一个连接到TCP网络套接字的通道
- 创建方式：
- 打开一个 SocketChannel 并连接到互联网上的某台服务器
- 一个新连接到达 ServerSocketChannel 时，会创建一个 SocketChannel
- 当用完 SocketChannel 之后调用 SocketChannel.close( ) 关闭 SocketChannel
- 要从 SocketChannel 中读取数据，调用一个 read() 的方法之一。首先，分配一个Buffer。从 SocketChannel 读取到的数据将会放到这个Buffer 中。然后，调用 SocketChannel.read( ) 。该方法将数据从 SocketChannel 读到 Buffer 中。read() 方法返回的 int 值表示读了多少字节进Buffer里。如果返回的是-1，表示已经读到了流的末尾（连接关闭了）。
- 注意 SocketChannel.write() 方法的调用是在一个while 循环中的。Write( ) 方法无法保证能写多少字节到 SocketChannel 。所以，我们重复调用 write( ) 直到 Buffer 没有要写的字节为止。
- 可以设置 SocketChannel 为非阻塞模式（non-blocking mode）.设置之后，就可以在异步模式下调用connect(), read() 和write()了。
- ServerSocketChannel：可以监听新进来的TCP连接，像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。
- 通过调用 ServerSocketChannel.open() 方法来打开ServerSocketChannel.
- 通过调用ServerSocketChannel.close() 方法来关闭ServerSocketChannel.
- 通过 ServerSocketChannel.accept() 方法监听新进来的连接。当 accept()方法返回的时候,它返回一个包含新进来的连接的 SocketChannel。因此, accept()方法会一直阻塞到有新连接到达。通常不会仅仅只监听一个连接,在while循环中调用 accept()方法.
- ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept() 方法会立刻返回，如果还没有新进来的连接,返回的将是null。 因此，需要检查返回的SocketChannel是否是null.

Buffers（缓冲区）

Java NIO中的Buffer用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。
缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

Buffer的基本用法

使用Buffer读写数据一般遵循以下四个步骤：
1. 写入数据到Buffer
2. 调用flip()方法
3. 从Buffer中读取数据
4. 调用clear()方法或者compact()方法

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。
一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

Buffer的工作原理

为了理解Buffer的工作原理，需要熟悉它的三个属性：
- capacity
- 作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。
- position
- 当你写数据到Buffer中时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1.
- 当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0. 当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。
- limit
- 在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。
- 当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

Buffer的类型

• ByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

尽管缓冲区作用于它们存储的原始数据类型，但缓冲区十分倾向于处理字节。非字节缓冲区可以在后台执行从字节或到字节的转换，这取决于缓冲区是如何创建的。

Buffer的分配

要想获得一个Buffer对象首先要进行分配。 每一个Buffer类都有一个allocate方法。
- 分配48字节capacity的ByteBuffer的例子：
ByteBuffer buf = ByteBuffer.allocate(48);
- 这是分配一个可存储1024个字符的CharBuffer：
CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中写数据

写数据到Buffer有两种方式：
- 从Channel写到Buffer
- int bytesRead = inChannel.read(buf); //read into buffer.
- 通过Buffer的put()方法写到Buffer里。
- buf.put(127);

flip()方法

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。
换句话说，position现在用于标记读的位置，limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。

从Buffer中读取数据

从Buffer中读取数据有两种方式：
- Buffer读取数据到Channel
- int bytesWritten = inChannel.write(buf);
- 使用get()方法从Buffer中读取数据。
- byte aByte = buf.get();

rewind( )方法

Buffer.rewind( )将position设回0，所以你可以重读Buffer中的所有数据。limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。

clear()与compact()方法

一旦读完Buffer中的数据，需要让Buffer准备好再次被写入。可以通过clear()或compact()方法来完成。
如果调用的是clear()方法，position将被设回0，limit被设置成 capacity的值。换句话说，Buffer 被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。
如果Buffer中有一些未读的数据，调用clear()方法，数据将“被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。
如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。
compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。

mark()与reset()方法

通过调用Buffer.mark()方法，可以标记Buffer中的一个特定position。之后可以通过调用Buffer.reset()方法恢复到这个position。

equals()与compareTo()方法

• equals() 当满足下列条件时，表示两个Buffer相等：
  
  • 有相同的类型（byte、char、int等）。
  • Buffer中剩余的byte、char等的个数相等。
  • Buffer中所有剩余的byte、char等都相同。

如你所见，equals只是比较Buffer的一部分，不是每一个在它里面的元素都比较。实际上，它只比较Buffer中的剩余元素。
- compareTo() 比较两个Buffer的剩余元素(byte、char等)， 如果满足下列条件，则认为一个Buffer“小于”另一个Buffer：
- 第一个不相等的元素小于另一个Buffer中对应的元素 。
- 所有元素都相等，但第一个Buffer比另一个先耗尽(第一个Buffer的元素个数比另一个少)。

ByteBuffer

ByteBuffer 只是 Buffer 的一个子类，但字节缓冲区有字节的独特之处。字节缓冲区跟其他缓冲区类型最明显的不同在于，它可以成为通道所执行的 I/O 的源头或目标，后面你会发现通道只接收 ByteBuffer 作为参数。
字节是操作系统及其 I/O 设备使用的基本数据类型。当在 JVM 和操作系统间传递数据时，将其他的数据类型拆分成构成它们的字节是十分必要的，系统层次的 I/O 面向字节的性质可以在整个缓冲区的设计以及它们互相配合的服务中感受到。同时，操作系统是在内存区域中进行 I/O 操作。这些内存区域，就操作系统方面而言，是相连的字节序列。于是，毫无疑问，只有字节缓冲区有资格参与 I/O 操作。

字节顺序

非字节类型的基本类型，除了布尔型都是由组合在一起的几个字节组成的。那么必然要引出另外一个问题：字节顺序。
多字节数值被存储在内存中的方式一般被称为 endian-ness（字节顺序）。如果数字数值的最高字节 － big end（大端），位于低位地址(即 big end 先写入内存，先写入的内存的地址是低位的，后写入内存的地址是高位的)，那么系统就是大端字节顺序。如果最低字节最先保存在内存中，那么系统就是小端字节顺序。在 java.nio 中，字节顺序由 ByteOrder 类封装：

package java.nio; 
public final class ByteOrder { 
public static final ByteOrder BIG_ENDIAN; 
public static final ByteOrder LITTLE_ENDIAN; 
public static ByteOrder nativeOrder(); 
public String toString(); 
} 

ByteOrder 类定义了决定从缓冲区中存储或检索多字节数值时使用哪一字节顺序的常量。如果你需要知道 JVM 运行的硬件平台的固有字节顺序，请调用静态类函数 nativeOrder()。
每个缓冲区类都具有一个能够通过调用 order() 查询的当前字节顺序：

public abstract class CharBuffer extends Buffer implements Comparable, CharSequence { 
// This is a partial API listing
public final ByteOrder order(); 
} 

这个函数从 ByteOrder 返回两个常量之一。对于除了 ByteBuffer 之外的其他缓冲区类，字节顺序是一个只读属性，并且可能根据缓冲区的建立方式而采用不同的值。除了 ByteBuffer，其他通过 allocate() 或 wrap() 一个数组所创建的缓冲区将从 order() 返回与 ByteOrder.nativeOrder() 相同的数值。这是因为包含在缓冲区中的元素在 JVM 中将会被作为基本数据直接存取
ByteBuffer 类有所不同：默认字节顺序总是 ByteBuffer.BIG_ENDIAN，无论系统的固有字节顺序是什么。Java 的默认字节顺序是大端字节顺序，这允许类文件等以及串行化的对象可以在任何 JVM 中工作。如果固有硬件字节顺序是小端，这会有性能隐患。在使用固有硬件字节顺序时，将 ByteBuffer 的内容当作其他数据类型存取很可能高效得多。
为什么 ByteBuffer 类需要一个字节顺序？字节不就是字节吗？ByteBuffer 对象像其他基本数据类型一样，具有大量便利的函数用于获取和存放缓冲区内容。这些函数对字节进行编码或解码的方式取决于 ByteBuffer 当前字节顺序的设定。ByteBuffer 的字节顺序可以随时通过调用以 ByteOrder.BIG_ENDIAN 或 ByteOrder.LITTL_ENDIAN 为参数的 order() 函数来改变：

public abstract class ByteBuffer extends Buffer implements Comparable { 
// This is a partial API listing
public final ByteOrder order(); 
public final ByteBuffer order(ByteOrder bo); 
} 

如果一个缓冲区被创建为一个 ByteBuffer 对象的视图，那么 order() 返回的数值就是视图被创建时其创建源头的 ByteBuffer 的字节顺序。视图的字节顺序设定在创建后不能被改变，而且如果原始的字节缓冲区的字节顺序在之后被改变，它也不会受到影响。

直接缓冲区

内核空间（与之相对的是用户空间，如 JVM）是操作系统所在区域，它能与设备控制器（硬件）通讯，控制着用户区域进程（如 JVM）的运行状态。最重要的是，所有的 I/O 都直接（物理内存）或间接（虚拟内存）通过内核空间。
当进程（如 JVM）请求 I/O 操作的时候，它执行一个系统调用将控制权移交给内核。当内核以这种方式被调用，它随即采取任何必要步骤，找到进程所需数据，并把数据传送到用户空间被你的指定缓冲区。内核试图对数据进行高速缓存或预读取，因此进程所需数据可能已经在内核空间里了。如果是这样，该数据只需简单地拷贝出来即可。如果数据不在内核空间，则进程被挂起，内核着手把数据读进内存。

从图中你可能会觉得，把数据从内核空间拷贝到用户空间似乎有些多余。为什么不直接让磁盘控制器把数据送到用户空间的缓冲区呢？首先，硬件通常不能直接访问用户空间。其次，像磁盘这样基于块存储的硬件设备操作的是固定大小的数据块，而用户进程请求的可能是任意大小的或非对齐的数据块。在数据往来于用户空间与存储设备的过程中，内核负责数据的分解、再组合工作，因此充当着中间人的角色
因此，操作系统是在内存区域中进行 I/O 操作。这些内存区域，就操作系统方面而言，是相连的字节序列，这也意味着I/O操作的目标内存区域必须是连续的字节序列。在 JVM中，字节数组可能不会在内存中连续存储（因为 JAVA 有 GC 机制），或者无用存储单元（会被垃圾回收）收集可能随时对其进行移动。
出于这个原因，引入了直接缓冲区的概念。直接字节缓冲区通常是 I/O 操作最好的选择。非直接字节缓冲区（即通过 allocate() 或 wrap() 创建的缓冲区）可以被传递给通道，但是这样可能导致性能损耗。通常非直接缓冲不可能成为一个本地 I/O 操作的目标。
如果你向一个通道中传递一个非直接 ByteBuffer 对象用于写入，通道可能会在每次调用中隐含地进行下面的操作：
1. 创建一个临时的直接 ByteBuffer 对象。
2. 将非直接缓冲区的内容复制到临时直接缓冲区中。
3. 使用临时直接缓冲区执行低层 I/O 操作。
4. 临时直接缓冲区对象离开作用域，并最终成为被回收的无用数据。

这可能导致缓冲区在每个 I/O 上复制并产生大量对象，而这种事都是我们极力避免的。如果你仅仅为一次使用而创建了一个缓冲区，区别并不是很明显。另一方面，如果你将在一段高性能脚本中重复使用缓冲区，分配直接缓冲区并重新使用它们会使你游刃有余。
直接缓冲区可能比创建非直接缓冲区要花费更高的成本，它使用的内存是通过调用本地操作系统方面的代码分配的，绕过了标准 JVM 堆栈，不受垃圾回收支配，因为它们位于标准 JVM 堆栈之外。
对于这部分感兴趣的同学可以看一下这篇文章 java之HeapByteBuffer&DirectByteBuffer以及回收DirectByteBuffer
直接 ByteBuffer 是通过调用具有所需容量的 ByteBuffer.allocateDirect() 函数产生的。注意: wrap() 函数所创建的被包装的缓冲区总是非直接的。与直接缓冲区相关的 api：

public abstract class ByteBuffer extends Buffer implements Comparable { 
// This is a partial API listing
public static ByteBuffer allocateDirect (int capacity); 
public abstract boolean isDirect(); 
} 

所有的缓冲区都提供了一个叫做 isDirect() 的 boolean 函数，来测试特定缓冲区是否为直接缓冲区。但是，ByteBuffer 是唯一可以被分配成直接缓冲区的 Buffer。尽管如此，如果基础缓冲区是一个直接 ByteBuffer，对于非字节视图缓冲区，isDirect() 可以是 true。

视图缓冲区

I/O 基本上可以归结成组字节数据的四处传递，在进行大数据量的 I/O 操作时，很又可能你会使用各种 ByteBuffer 类去读取文件内容，接收来自网络连接的数据，等等。ByteBuffer 类提供了丰富的 API 来创建视图缓冲区。
视图缓冲区通过已存在的缓冲区对象实例的工厂方法来创建。这种视图对象维护它自己的属性，容量，位置，上界和标记，但是和原来的缓冲区共享数据元素。
每一个工厂方法都在原有的 ByteBuffer 对象上创建一个视图缓冲区。调用其中的任何一个方法都会创建对应的缓冲区类型，这个缓冲区是基础缓冲区的一个切分，由基础缓冲区的位置和上界决定。新的缓冲区的容量是字节缓冲区中存在的元素数量除以视图类型中组成一个数据类型的字节数，在切分中任一个超过上界的元素对于这个视图缓冲区都是不可见的。视图缓冲区的第一个元素从创建它的 ByteBuffer 对象的位置开始（positon( ) 函数的返回值）。来自 ByteBuffer 创建视图缓冲区的工厂方法：

public abstract class ByteBuffer extends Buffer implements Comparable { 
// This is a partial API listing
public abstract CharBuffer asCharBuffer(); 
public abstract ShortBuffer asShortBuffer( ); 
public abstract IntBuffer asIntBuffer( ); 
public abstract LongBuffer asLongBuffer( ); 
public abstract FloatBuffer asFloatBuffer( ); 
public abstract DoubleBuffer asDoubleBuffer( ); 
} 

下面的代码创建了一个 ByteBuffer 缓冲区的 CharBuffer 视图。演示 7 个字节的 ByteBuffer 的 CharBuffer 视图：

/**
* 1 char = 2 byte，因此 7 个字节的 ByteBuffer 最终只会产生 capacity 为 3 的 CharBuffer。
*
* 无论何时一个视图缓冲区存取一个 ByteBuffer 的基础字节，这些字节都会根据这个视图缓冲区的字节顺序设
* 定被包装成一个数据元素。当一个视图缓冲区被创建时，视图创建的同时它也继承了基础 ByteBuffer 对象的
* 字节顺序设定，这个视图的字节排序不能再被修改。字节顺序设定决定了这些字节对是怎么样被组合成字符
* 型变量的，这样可以理解为什么 ByteBuffer 有字节顺序的概念了吧。
*/
ByteBuffer byteBuffer = ByteBuffer.allocate (7).order (ByteOrder.BIG_ENDIAN); 
CharBuffer charBuffer = byteBuffer.asCharBuffer(); 

数据元素视图

ByteBuffer 类为每一种原始数据类型提供了存取的和转化的方法：

public abstract class ByteBuffer extends Buffer implements Comparable { 
public abstract short getShort( );  
public abstract short getShort(int index); 
public abstract short getInt( );  
public abstract short getInt(int index); 
    ...... 
public abstract ByteBuffer putShort(short value);  
public abstract ByteBuffer putShort(int index, short value); 
public abstract ByteBuffer putInt(int value);  
public abstract ByteBuffer putInt(int index, int value); 
    ....... 
} 

这些函数从当前位置开始存取 ByteBuffer 的字节数据，就好像一个数据元素被存储在那里一样。根据这个缓冲区的当前的有效的字节顺序，这些字节数据会被排列或打乱成需要的原始数据类型。
如果 getInt() 函数被调用，从当前的位置开始的四个字节会被包装成一个 int 类型的变量然后作为函数的返回值返回。实际的返回值取决于缓冲区的当前的比特排序（byte-order）设置。不同字节顺序取得的值是不同的：

// 大端顺序
int value = http://www.mamicode.com/buffer.order(ByteOrder.BIG_ENDIAN).getInt(); "hljs-comment">// 小端顺序
int value = http://www.mamicode.com/buffer.order(ByteOrder.LITTLE_ENDIAN).getInt(); "hljs-comment">// 上述两种方法取得的 int 是不一样的，因此在调用此类方法前，请确保字节顺序是你所期望的

如果你试图获取的原始类型需要比缓冲区中存在的字节数更多的字节，会抛出 BufferUnderflowException。

Selector

Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。

为什么使用Selector?

仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道。对于操作系统来说，线程之间上下文切换的开销很大，而且每个线程都要占用系统的一些资源（如内存）。因此，使用的线程越少越好。
但是，需要记住，现代的操作系统和CPU在多任务方面表现的越来越好，所以多线程的开销随着时间的推移，变得越来越小了。实际上，如果一个CPU有多个内核，不使用多任务可能是在浪费CPU能力。不管怎么说，关于那种设计的讨论应该放在另一篇不同的文章中。在这里，只要知道使用Selector能够处理多个通道就足够了。
下面是单线程使用一个Selector处理3个channel的示例图：

Selector的创建

为了将Channel和Selector配合使用，必须将channel注册到selector上。通过SelectableChannel.register()方法来实现，如下：

channel.configureBlocking(false);
SelectionKey key = channel.register(selector, Selectionkey.OP_READ);

与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。
注意register()方法的第二个参数。这是一个“interest集合”，意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件：
- Connect
- Accept
- Read
- Write
通道触发了一个事件意思是该事件已经就绪。所以，某个channel成功连接到另一个服务器称为“连接就绪”。一个server socket channel准备好接收新进入的连接称为“接收就绪”。一个有数据可读的通道可以说是“读就绪”。等待写数据的通道可以说是“写就绪”。
这四种事件用SelectionKey的四个常量来表示：
- SelectionKey.OP_CONNECT
- SelectionKey.OP_ACCEPT
- SelectionKey.OP_READ
- SelectionKey.OP_WRITE
如果你对不止一种事件感兴趣，那么可以用“位或”操作符将常量连接起来，如下：
int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

当向Selector注册Channel时，register()方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性：
- interest集合
- interest集合是你所选择的感兴趣的事件集合
- 可以通过SelectionKey读写interest集合，可以看到，用“位与”操作interest 集合和给定的SelectionKey常量，可以确定某个确定的事件是否在interest 集合中。

int interestSet = selectionKey.interestOps();
boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;  

• ready集合
  
  • ready 集合是通道已经准备就绪的操作的集合。在一次选择(Selection)之后，你会首先访问这个ready set。可以这样访问ready集合：int readySet = selectionKey.readyOps();
  • 可以用像检测interest集合那样的方法，来检测channel中什么事件或操作已经就绪。但是，也可以使用以下四个方法，它们都会返回一个布尔类型：

selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

• Channel
  
  • Channel channel = selectionKey.channel();
• Selector
  
  • Selector selector = selectionKey.selector();
• 附加的对象（可选）
  
  • 可以将一个对象或者更多信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。
  • 还可以在用register()方法向Selector注册Channel的时候附加对象

通过Selector选择通道

一旦向Selector注册了一或多个通道，就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如连接、接受、读或写）已经准备就绪的那些通道。换句话说，如果你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。
- int select()
- 阻塞到至少有一个通道在你注册的事件上就绪了。
- select()方法返回的int值表示有多少通道已经就绪。亦即，自上次调用select()方法后有多少通道变成就绪状态。如果调用select()方法，因为有一个通道变成就绪状态，返回了1，若再次调用select()方法，如果另一个通道就绪了，它会再次返回1。如果对第一个就绪的channel没有做任何操作，现在就有两个就绪的通道，但在每次select()方法调用之间，只有一个通道就绪了。
- int select(long timeout)
- select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。
- int selectNow()
- selectNow()不会阻塞，不管什么通道就绪都立刻返回（译者注：此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，则此方法直接返回零。）。

selectedKeys()

一旦调用了select()方法，并且返回值表明有一个或更多个通道就绪了，然后可以通过调用selector的selectedKeys()方法，访问“已选择键集（selected key set）”中的就绪通道。如下所示：
Set selectedKeys = selector.selectedKeys();
当像Selector注册Channel时，Channel.register()方法会返回一个SelectionKey 对象。这个对象代表了注册到该Selector的通道。可以通过SelectionKey的selectedKeySet()方法访问这些对象。
可以遍历这个已选择的键集合来访问就绪的通道。如下：

Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove();
}

这个循环遍历已选择键集中的每个键，并检测各个键所对应的通道的就绪事件。
注意每次迭代末尾的keyIterator.remove()调用。Selector不会自己从已选择键集中移除SelectionKey实例。必须在处理完通道时自己移除。下次该通道变成就绪时，Selector会再次将其放入已选择键集中。
SelectionKey.channel()方法返回的通道需要转型成你要处理的类型，如ServerSocketChannel或SocketChannel等。

wakeUp()

某个线程调用select()方法后阻塞了，即使没有通道已经就绪，也有办法让其从select()方法返回。只要让其它线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法即可。阻塞在select()方法上的线程会立马返回。
如果有其它线程调用了wakeup()方法，但当前没有线程阻塞在select()方法上，下个调用select()方法的线程会立即“醒来（wake up）”。

close()

用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的所有SelectionKey实例无效。通道本身并不会关闭。

Scatter/Gather

Java NIO开始支持scatter/gather，scatter/gather用于描述从Channel中读取或者写入到Channel的操作。
- 分散（scatter）从Channel中读取：是指在读操作时将读取的数据写入多个buffer中。因此，Channel将从Channel中读取的数据“分散（scatter）”到多个Buffer中。
- 聚集（gather）写入Channel：是指在写操作时将多个buffer的数据写入同一个Channel，因此，Channel 将多个Buffer中的数据“聚集（gather）”后发送到Channel。
- scatter / gather经常用于需要将传输的数据分开处理的场合，例如传输一个由消息头和消息体组成的消息，你可能会将消息体和消息头分散到不同的buffer中，这样你可以方便的处理消息头和消息体。

Scattering Reads

是指数据从一个channel读取到多个buffer中。如下图描述：

代码示例如下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);
ByteBuffer[] bufferArray = { header, body };
channel.read(bufferArray);

注意buffer首先被插入到数组，然后再将数组作为channel.read() 的输入参数。read()方法按照buffer在数组中的顺序将从channel中读取的数据写入到buffer，当一个buffer被写满后，channel紧接着向另一个buffer中写。
Scattering Reads在移动下一个buffer前，必须填满当前的buffer，这也意味着它不适用于动态消息(译者注：消息大小不固定)。换句话说，如果存在消息头和消息体，消息头必须完成填充（例如 128byte），Scattering Reads才能正常工作。

Gathering Writes

Gathering Writes是指数据从多个buffer写入到同一个channel。如下图描述：

代码示例如下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);
//write data into buffers
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);

buffers数组是write()方法的入参，write()方法会按照buffer在数组中的顺序，将数据写入到channel，注意只有position和limit之间的数据才会被写入。因此，如果一个buffer的容量为128byte，但是仅仅包含58byte的数据，那么这58byte的数据将被写入到channel中。因此与Scattering Reads相反，Gathering Writes能较好的处理动态消息。

通道之间的数据传输

在Java NIO中，如果两个通道中有一个是FileChannel，那你可以直接将数据从一个channel（译者注：channel中文常译作通道）传输到另外一个channel。

transferFrom()

FileChannel的transferFrom()方法可以将数据从源通道传输到FileChannel中（译者注：这个方法在JDK文档中的解释为将字节从给定的可读取字节通道传输到此通道的文件中）。下面是一个简单的例子：

RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel fromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel toChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
toChannel.transferFrom(position, count, fromChannel);

方法的输入参数position表示从position处开始向目标文件写入数据，count表示最多传输的字节数。如果源通道的剩余空间小于 count 个字节，则所传输的字节数要小于请求的字节数。
此外要注意，在SoketChannel的实现中，SocketChannel只会传输此刻准备好的数据（可能不足count字节）。因此，SocketChannel可能不会将请求的所有数据(count个字节)全部传输到FileChannel中。

transferTo()

transferTo()方法将数据从FileChannel传输到其他的channel中。下面是一个简单的例子：

RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel      fromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel      toChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
fromChannel.transferTo(position, count, toChannel);

是不是发现这个例子和前面那个例子特别相似？除了调用方法的FileChannel对象不一样外，其他的都一样。
上面所说的关于SocketChannel的问题在transferTo()方法中同样存在。SocketChannel会一直传输数据直到目标buffer被填满。

Pipe

Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。
这里是Pipe原理的图示：

- 创建管道
- 通过Pipe.open()方法打开管道
- 向管道写数据
- 要向管道写数据，需要访问sink通道。像这样：Pipe.SinkChannel sinkChannel = pipe.sink();
- 从管道读取数据
- 从读取管道的数据，需要访问source通道，像这样：Pipe.SourceChannel sourceChannel = pipe.source();

Java NIO和IO的主要区别

面向流与面向缓冲

Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

阻塞与非阻塞IO

Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

选择器（Selectors）

Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

NIO和IO如何影响应用程序的设计

无论您选择IO或NIO工具箱，可能会影响您应用程序设计的以下几个方面：
1. 对NIO或IO类的API调用。
2. 数据处理。
3. 用来处理数据的线程数。

API调用

当然，使用NIO的API调用时看起来与使用IO时有所不同，但这并不意外，因为并不是仅从一个InputStream逐字节读取，而是数据必须先读入缓冲区再处理。

数据处理

使用纯粹的NIO设计相较IO设计，数据处理也受到影响。
在IO设计中，我们从InputStream或 Reader逐字节读取数据。假设你正在处理一基于行的文本数据流，例如：

Name: Anna
Age: 25
Email: anna@mailserver.com
Phone: 1234567890

该文本行的流可以这样处理：
InputStream input = … ; // get the InputStream from the client socket

BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String nameLine   = reader.readLine();
String ageLine    = reader.readLine();
String emailLine  = reader.readLine();
String phoneLine  = reader.readLine();

请注意处理状态由程序执行多久决定。换句话说，一旦reader.readLine()方法返回，你就知道肯定文本行就已读完， readline()阻塞直到整行读完，这就是原因。你也知道此行包含名称；同样，第二个readline()调用返回的时候，你知道这行包含年龄等。 正如你可以看到，该处理程序仅在有新数据读入时运行，并知道每步的数据是什么。一旦正在运行的线程已处理过读入的某些数据，该线程不会再回退数据（大多如此）。（Java IO: 从一个阻塞的流中读数据） 而一个NIO的实现会有所不同，下面是一个简单的例子：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);

注意第二行，从通道读取字节到ByteBuffer。当这个方法调用返回时，你不知道你所需的所有数据是否在缓冲区内。你所知道的是，该缓冲区包含一些字节，这使得处理有点困难。
假设第一次 read(buffer)调用后，读入缓冲区的数据只有半行，例如，“Name:An”，你能处理数据吗？显然不能，需要等待，直到整行数据读入缓存，在此之前，对数据的任何处理毫无意义。
所以，你怎么知道是否该缓冲区包含足够的数据可以处理呢？好了，你不知道。发现的方法只能查看缓冲区中的数据。其结果是，在你知道所有数据都在缓冲区里之前，你必须检查几次缓冲区的数据。这不仅效率低下，而且可以使程序设计方案杂乱不堪。例如：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);
while(! bufferFull(bytesRead) ) {
    bytesRead = inChannel.read(buffer);
}

bufferFull()方法必须跟踪有多少数据读入缓冲区，并返回真或假，这取决于缓冲区是否已满。换句话说，如果缓冲区准备好被处理，那么表示缓冲区满了。
bufferFull()方法扫描缓冲区，但必须保持在bufferFull（）方法被调用之前状态相同。如果没有，下一个读入缓冲区的数据可能无法读到正确的位置。这是不可能的，但却是需要注意的又一问题。
如果缓冲区已满，它可以被处理。如果它不满，并且在你的实际案例中有意义，你或许能处理其中的部分数据。
Java NIO:从一个通道里读数据，直到所有的数据都读到缓冲区里.
NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。
- 如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，如聊天服务器，实现NIO的服务器可能是一个优势。
- 如果你需要维持许多打开的连接到其他计算机上，P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。