Java NIO Buffer详解-优快云博客

本文链接：https://blog.youkuaiyun.com/iteye_17023/article/details/81620305

内容一、基本概念

java.io.Buffer的相关定义：A container for data of a specific primitive type.

（这点上很类似于DataInputStream,DataOutputStream，不同的是一个提供的是基于流的操作，具有单向，不可逆性；Buffer不再是流了。）

/**
* A container for data of a specific primitive type.
*
* A buffer is a linear, finite sequence of elements of a specific
* primitive type. Aside from its content, the essential properties of a
* buffer are its capacity, limit, and position:

* （0<=position<=limit<=capacity 注：capacity一旦确定就不能更改）
*
* <blockquote>
*
* A buffer's capacity is the number of elements it contains. The
* capacity of a buffer is never negative and never changes. 
*
* A buffer's limit is the index of the first element that should
* not be read or written. A buffer's limit is never negative and is never
* greater than its capacity. 
*
* A buffer's position is the index of the next element to be
* read or written. A buffer's position is never negative and is never
* greater than its limit. 
*
* </blockquote>

内容二、基本操作

* <h4> Transferring data </h4> 存取数据
*
* Each subclass of this class defines two categories（绝对和相对存取） of get and
* put operations: 
* （相对以前的IoStream变化体现在操作更为灵活，不仅局限于单向，不可以逆的流操作。）
* <blockquote>
*
* Relative operations read or write one or more elements starting
* at the current position and then increment the position by the number of
* elements transferred. If the requested transfer exceeds the limit then a
* relative get operation throws a {@link BufferUnderflowException}
* and a relative put operation throws a {@link
* BufferOverflowException}; in either case, no data is transferred.

读写异常：

get （if： current+requested > limit） throw: BufferUnderflowException

write （if: current+requested > limit） throw: BufferOverflowException
*
* Absolute operations take an explicit element index and do not
* affect the position. Absolute get and put operations throw
* an {@link IndexOutOfBoundsException} if the index argument exceeds the
* limit.

内容三、标记

* <h4> Marking and resetting </h4>
*在IoStream中也有类似的操作，只是为了这种流操作的单向性。
* A buffer's mark is the index to which its position will be reset
* when the {@link #reset reset} method is invoked. The mark is not always
* defined, but when it is defined it is never negative and is never greater
* than the position. If the mark is defined then it is discarded when the
* position or the limit is adjusted to a value smaller than the mark.（mark被隐含失效）

If the mark is not defined then invoking the {@link #reset reset} method causes an
* {@link InvalidMarkException} to be thrown.

内容四、控制

<h4> Clearing, flipping, and rewinding </h4>
*
* In addition to methods for accessing the position, limit, and capacity
* values and for marking and resetting,

this class also defines the following operations upon buffers:
*
* <ul>
*
* <li> {@link #clear} makes a buffer ready for a new sequence of
* channel-read or relative put operations: It sets the limit to the
* capacity and the position to zero. </li>
*
* <li> {@link #flip} makes a buffer ready for a new sequence of
* channel-write or relative get operations: It sets the limit to the
* current position and then sets the position to zero. </li>
*

当我们创建完毕一个Buffer以后，我们应该养成这样的习惯：

（1）放数据前，clear下，确保position从0开始写；（2）取数据前，flip下，确保我们只取有效数据【一般(limit,capacity]间的数据全部是0】。

（3）如果我们要改变流操作的特性，需要对同一份数据进行多次读取的话，那么如果【全部复读】，则直接rewind下；如果【部分复读】则使用mark and reset。
* <li> {@link #rewind} makes a buffer ready for re-reading the data that
* it already contains: It leaves the limit unchanged and sets the position
* to zero. </li>
*
* </ul>
*

public class ByteBufferDemo {

 public static void main(String[] args) {

  ByteBuffer buf = ByteBuffer.allocateDirect(12);
  buf.clear();//put前准备操作
  buf.putInt(10);
  buf.putInt(20);
 //buf.putInt(30);//留4个字节没放东西，所以有效空间是[0,8)
  buf.flip();//get前准备操作
  System.out.println(buf.getInt());
  System.out.println(buf.getInt());
  System.out.println(buf.getInt());//读取时超过了有效范围

//  【全部复读】
  buf.rewind();
  System.out.println(buf.getInt());
  System.out.println(buf.getInt());
  
//  【部分复读】
  System.out.println("演示复读");
  buf.rewind();
  System.out.println(buf.getInt());
//  现在要对第2个int复读两次
  buf.mark();
  System.out.println(buf.getInt());//第一次读取
  buf.reset();//准备第二次读取
  System.out.println(buf.getInt());

  /* 10
   * 20
   * Exception in thread "main" java.nio.BufferUnderflowException
 at java.nio.Buffer.nextGetIndex(Buffer.java:404)
 at java.nio.DirectByteBuffer.getInt(DirectByteBuffer.java:620)
 at com.umpay.construct.ByteBufferDemo.main(ByteBufferDemo.java:17)
   * */
 }

内容五、注意事项

（1）非线程安全

* <h4> Thread safety </h4>
*
* Buffers are not safe （非线程安全）for use by multiple concurrent threads. If a
* buffer is to be used by more than one thread then access to the buffer
* should be controlled by appropriate synchronization.

（2）只读

* <h4> Read-only buffers </h4>
*
* Every buffer is readable, but not every buffer is writable. The
* mutation（指：会改变对象状态的方法） methods of each buffer class are specified as optional
* operations that will throw a {@link ReadOnlyBufferException} when
* invoked upon a read-only buffer. A read-only buffer does not allow its
* content to be changed, but its mark, position, and limit values are mutable. （因为：这些变量都属于内部维护的变量InVar）
* Whether or not a buffer is read-only may be determined by invoking its
* {@link #isReadOnly isReadOnly} method.
*