【Java】Java NIO 之 Buffer 缓冲区（二）
一、Buffer(缓冲区)介绍
1.1、Buffer(缓冲区)介绍
Java NIO Buffers用于和NIO Channel交互。 我们从Channel中读取数据到buffers里，从Buffer把数据写入到Channels.
Buffer本质上就是一块内存区，可以用来写入数据，并在稍后读取出来。这块内存被NIO Buffer包裹起来，对外提供一系列的读写方便开发的接口。
在Java NIO中使用的核心缓冲区如下（覆盖了通过I/O发送的基本数据类型：byte, char、short, int, long, float, double）
ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
FloatBuffer
DoubleBuffer
LongBuffer
1.2、Buffer的基本用法
使用Buffer读写数据一般遵循以下四个步骤：
- 写入数据到Buffer
- 调用
flip()方法 - 从Buffer中读取数据
- 调用
clear()方法或者compact()方法
当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。
一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。
1.3、Buffer的容量，位置，上限（Buffer Capacity, Position and Limit）
Buffer缓冲区实质上就是一块内存，用于写入数据，也供后续再次读取数据。这块内存被NIO Buffer管理，并提供一系列的方法用于更简单的操作这块内存。
一个Buffer有三个属性是必须掌握的，分别是：
capacity（容量）
position（位置）
limit（限制）
position和limit的具体含义取决于当前buffer的模式。capacity在两种模式下都表示容量。
这里有一个关于capacity，position和limit在读写模式中的说明，详细的解释在插图后面。
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的常见方法
| 方法 | 介绍 |
|---|---|
| abstract Object array() | 返回支持此缓冲区的数组 （可选操作） |
| abstract int arrayOffset() | 返回该缓冲区的缓冲区的第一个元素的在数组中的偏移量 （可选操作） |
| int capacity() | 返回此缓冲区的容量 |
| Buffer clear() | 清除此缓存区。将position = 0;limit = capacity;mark = -1; |
| Buffer flip() | flip()方法可以吧Buffer从写模式切换到读模式。调用flip方法会把position归零，并设置limit为之前的position的值。 也就是说，现在position代表的是读取位置，limit标示的是已写入的数据位置。 |
| abstract boolean hasArray() | 告诉这个缓冲区是否由可访问的数组支持 |
| boolean hasRemaining() | return position < limit，返回是否还有未读内容 |
| abstract boolean isDirect() | 判断个缓冲区是否为 direct |
| abstract boolean isReadOnly() | 判断告知这个缓冲区是否是只读的 |
| int limit() | 返回此缓冲区的限制 |
| Buffer position(int newPosition) | 设置这个缓冲区的位置 |
| int remaining() | return limit - position; 返回limit和position之间相对位置差 |
| Buffer rewind() | 把position设为0，mark设为-1，不改变limit的值 |
| Buffer mark() | 将此缓冲区的标记设置在其位置 |
三、Buffer的使用方式/方法介绍
3.1、分配缓冲区（Allocating a Buffer）
为了获得缓冲区对象，我们必须首先分配一个缓冲区。在每个Buffer类中，allocate()方法用于分配缓冲区。
下面是一个分配48字节capacity的ByteBuffer的例子：
1 ByteBuffer buf = ByteBuffer.allocate(48);
这是分配一个可存储1024个字符的CharBuffer：
1 CharBuffer buf = CharBuffer.allocate(1024);
3.2、写入数据到缓冲区（Writing Data to a Buffer）
写数据到Buffer有两种方法：
从Channel中写数据到Buffer
手动写数据到Buffer，调用put方法
从Channel写到Buffer的例子
1 int bytesRead = inChannel.read(buf); //read into buffer.
通过put方法写Buffer的例子：
1 buf.put(127);
put方法有很多版本，允许你以不同的方式把数据写入到Buffer中。例如， 写到一个指定的位置，或者把一个字节数组写入到Buffer。 更多Buffer实现的细节参考JavaDoc。
3.3、翻转（flip()）
flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。
换句话说，position现在用于标记读的位置，limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。
3.4、从Buffer读取数据（Reading Data from a Buffer）
从Buffer读数据也有两种方式。
从buffer读数据到channel
从buffer直接读取数据，调用get方法
从Buffer读取数据到Channel的例子：
1 //read from buffer into channel.2 int bytesWritten = inChannel.write(buf);
使用get()方法从Buffer中读取数据的例子
1 byte aByte = buf.get();
get方法有很多版本，允许你以不同的方式从Buffer中读取数据。例如，从指定position读取，或者从Buffer中读取数据到字节数组。更多Buffer实现的细节参考JavaDoc。
3.5、rewind()方法
Buffer.rewind()将position设回0，所以你可以重读Buffer中的所有数据。limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。
3.6、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准备好写数据了，但是不会覆盖未读的数据。
3.7、mark()与reset()方法
通过调用Buffer.mark()方法，可以标记Buffer中的一个特定position。之后可以通过调用Buffer.reset()方法恢复到这个position。例如：
1 buffer.mark();2
3 //call buffer.get() a couple of times, e.g. during parsing.
4
5 buffer.reset(); //set position back to mark.
3.8、equals()与compareTo()方法
可以使用equals()和compareTo()方法两个Buffer。
equals()
当满足下列条件时，表示两个Buffer相等：
- 有相同的类型（byte、char、int等）。
- Buffer中剩余的byte、char等的个数相等。
- Buffer中所有剩余的byte、char等都相同。
如你所见，equals只是比较Buffer的一部分，不是每一个在它里面的元素都比较。实际上，它只比较Buffer中的剩余元素。
compareTo()方法
compareTo()方法比较两个Buffer的剩余元素(byte、char等)， 如果满足下列条件，则认为一个Buffer“小于”另一个Buffer：
- 第一个不相等的元素小于另一个Buffer中对应的元素 。
- 所有元素都相等，但第一个Buffer比另一个先耗尽(第一个Buffer的元素个数比另一个少)。
四、Buffer常用方法测试
这里以ByteBuffer为例子说明抽象类Buffer的实现类的一些常见方法的使用：
1 /**2 * 1、缓冲区（Buffer）：
3 * 在Java NIO 中负责数据的存取，缓冲区九是数组，用于存储不同数据类型的数据
4 * 根据数据类型不同（boolean除外），提供了相应类型的缓冲区
5 * ByteBuffer
6 * CharBuffer
7 * ShortBuffer
8 * IntBuffer
9 * LongBuffer
10 * FloatBuffer
11 * DoubleBuffer
12 *
13 * 2、缓冲区存取数据的两个核心方法：
14 * put() ：存入数据到缓冲区中
15 * get()：获取缓冲区中的数据
16 *
17 * 3、缓冲区中的四个核心属性：
18 * capacity：容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变
19 * limit：界限，表示缓冲区中可以操作数据的大小，代表了当前缓冲区中一共有多少数据。。（limit 后数据不能进行读写）
20 * position：位置，表示缓冲区中正在操作数据的位置，Position会自动由相应的 get( )和 put( )函数更新
21 * mark：标记，一个备忘位置。用于记录当前position位置，可以通过过reset() 恢复到 mark 的位置。
22 *
23 * 规律
24 * mark <= position <= limit <= capacity
25 *
26 * 4、直接缓冲区与非直接缓冲区
27 * 非直接缓冲区：通过allocate() 方法分配，将缓冲区建立在 JVM 的内存中
28 * 直接缓冲区：通过allocateDirect() 方法分配，将缓冲区建立在物理内存中，可以提高效率
29 *
30 *
31 */
32 public class BufferTest {
33
34 /**
35 * 测试常用方法
36 */
37 @Test
38 public void test1(){
39 // 1、分配一个指定大小的缓存区
40 ByteBuffer buf = ByteBuffer.allocate(5);
41
42 System.out.println("----------allocate()---------");
43 System.out.println("position == " + buf.position());
44 System.out.println("limit == " + buf.limit());
45 System.out.println("capacity == " + buf.capacity());
46
47
48 // 2、利用put() 存入数据到缓冲区区
49 buf.put("abcde".getBytes());
50
51 System.out.println("----------put()---------");
52 System.out.println("position == " + buf.position());
53 System.out.println("limit == " + buf.limit());
54 System.out.println("capacity == " + buf.capacity());
55
56 // 3、利用flip() 切换读取数据模式
57 buf.flip();
58
59 System.out.println("----------flip()---------");
60 System.out.println("position == " + buf.position());
61 System.out.println("limit == " + buf.limit());
62 System.out.println("capacity == " + buf.capacity());
63
64 // 4、利用get() 读取缓冲区中的数据
65 byte[] dst = new byte[buf.limit()];
66 buf.get(dst);
67
68 System.out.println("----------get()---------");
69 System.out.println("position == " + buf.position());
70 System.out.println("limit == " + buf.limit());
71 System.out.println("capacity == " + buf.capacity());
72
73 System.out.println(new String(dst, 0, dst.length));
74
75 // 5、利用rewind() 回到读模式（可重复读数据）
76 buf.rewind();
77
78 System.out.println("----------rewind()---------");
79 System.out.println("position == " + buf.position());
80 System.out.println("limit == " + buf.limit());
81 System.out.println("capacity == " + buf.capacity());
82
83 // 6、利用clear() 清空缓冲区，当是缓冲区的数据还在，可看源码
84 buf.clear();
85
86 System.out.println("----------clear()---------");
87 System.out.println("position == " + buf.position());
88 System.out.println("limit == " + buf.limit());
89 System.out.println("capacity == " + buf.capacity());
90
91 // 测试数据并未被清空
92 System.out.println((char)buf.get());
93
94 }
95
96 /**
97 * 测试mark 方法
98 */
99 @Test
100 public void test2(){
101 ByteBuffer buf = ByteBuffer.allocate(1024);
102 buf.put("abcdefg".getBytes());
103 buf.flip();
104
105 byte[] dst = new byte[buf.limit()];
106 buf.get(dst, 0, 2);
107 System.out.println(new String(dst, 0, 2));
108 System.out.println("position === " + buf.position());
109
110 buf.mark();
111
112 buf.get(dst, 2, 2);
113 System.out.println(new String(dst, 2, 2));
114 System.out.println("position === " + buf.position());
115
116 // 重置到mark的位置
117 buf.reset();
118 System.out.println("position === " + buf.position());
119
120
121 // 判断缓冲区中是否还有剩余数据
122 if(buf.hasRemaining()) {
123 // 获取缓冲区中，可以操作的数据数量
124 System.out.println("remaining === " + buf.remaining());
125 }
126 }
127
128 /**
129 * 直接缓冲区与非直接缓冲区
130 */
131 @Test
132 public void test3(){
133 ByteBuffer buf = ByteBuffer.allocateDirect(1024);
134
135 System.out.println(buf.isDirect());
136 }
137 }
编码解码示例：
1 // 5】字符集2 @Test
3 public void test5(){
4 SortedMap<String, Charset> map = Charset.availableCharsets();
5
6 Set<Map.Entry<String, Charset>> set = map.entrySet();
7
8 for (Map.Entry<String, Charset> entry: set) {
9 System.out.println(entry.getKey() + " === " + entry.getValue());
10 }
11 }
12
13 // 6】测试字符集
14 @Test
15 public void test6(){
16
17 try {
18
19 Charset cs1 = Charset.forName("UTF-8");
20 // 获取编码器
21 CharsetEncoder ce = cs1.newEncoder();
22
23 // 获取解码器
24 CharsetDecoder cd = cs1.newDecoder();
25
26 CharBuffer cBuf = CharBuffer.allocate(1024);
27 cBuf.put("我是中国人");
28 cBuf.flip();
29
30 // 编码
31 ByteBuffer bBuf = ce.encode(cBuf);
32 for (int i = 0; i < 12 && i < bBuf.limit(); i ++ ) {
33 System.out.println(bBuf.get());
34 }
35
36 // 解码
37 bBuf.flip();
38 CharBuffer cBuf2 = cd.decode(bBuf);
39 System.out.println(cBuf2.toString());
40
41 System.out.println("-----------------");
42
43 // 编码解码不一致
44 bBuf.flip();
45 Charset cs2 = Charset.forName("GBK");
46 CharBuffer cBuf3 = cs2.decode(bBuf);
47 System.out.println(cBuf3.toString());
48 } catch (CharacterCodingException e) {
49 e.printStackTrace();
50 }
51
52 }
View Code
以上是 【Java】Java NIO 之 Buffer 缓冲区（二） 的全部内容， 来源链接： utcz.com/z/390817.html
