Nio基础之position，limit概念

Nio的基本概念：https://baike.baidu.com/item/java.nio/5180052?fr=aladdin 百度百科

本处仅演示下Buffer的几个概念和Api;

以ByteBuffer缓冲区为例；

1. 创建缓冲区
   1. ByteBuffer bb = ByteBuffer.allocate(10);
2. bb.position();
   1. 代表的是数据指针的位置；
3. bb.capacity();
   1. 缓冲区的容量，在初始化之后都不会变，一直为10；
4. bb.limit();
5. 用于限制读取数据的范围指针位置，限制可读取的范围，大于limit的位置不会被读取；
6. bb.flip();
   1. 开启读取模式
   2. filp()方法将会做以下几件事情：
      1. 将position位置清零；
      2. 将limit指针放置在之前的position位置；
7. bb.rewind();
   1. 开启重复读模式；
   2. rewind()方法会将position清零，重新读取；
8. bb.clear();
   1. 重新初始化；
   2. clear() 会重新初始化缓冲区到初始化状态，即 position=0 capacity=10 limit=10 ， 但是数据还在；

代码演示：

package test;

import java.nio.ByteBuffer;

public class NioTest {
	
	public static void main(String[] args){
		
		System.out.println("缓冲区初始化状态------------");
		ByteBuffer bb = ByteBuffer.allocate(10);//初始化10个字节的缓冲区
		
		int position = bb.position();  //此时未添加数据，值为0；代表的是指针的位置；
	    int capacity = bb.capacity();  // 缓冲区的容量，在初始化之后都不会变，一直为10；
		int limit = bb.limit();     // 用于限制读取数据的范围指针位置，限制可读取的范围，大于limit的位置不会被读取；
		
		System.out.println("position="+position);
		System.out.println("capacity="+capacity);
		System.out.println("limit="+limit);

		
		System.out.println("缓冲区添加 123 三个字节------------");
		bb.put("123".getBytes());   // 添加了三个字节  123 
		int position1 = bb.position();  //此时未添加数据，值为0；代表的是指针的位置；
	    int capacity1 = bb.capacity();  // 缓冲区的容量，在初始化之后都不会变，一直为10；
		int limit1 = bb.limit();     // 用于限制读取数据的范围指针位置，限制可读取的范围，大于limit的位置不会被读取；
		
		System.out.println("position1="+position1);
		System.out.println("capacity1="+capacity1);
		System.out.println("limit1="+limit1);
		
		
		
		System.out.println("缓冲区开启读取模式，未读状态------------");
		bb.flip();    //开启读取模式
		int position2 = bb.position(); // filp()方法将会做以下几件事情： 1. 将position位置清零； 2. 将limit指针放置在之前的position位置；
	    int capacity2 = bb.capacity(); // 缓冲区容量自定义之后便一直不会便；
		int limit2 = bb.limit();   // flip()使 limit变为之前的position位置，为3；
		
		System.out.println("position2="+position2);
		System.out.println("capacity2="+capacity2);
		System.out.println("limit2="+limit2);
		
		
		System.out.println("缓冲区开启读取模式，读取之后状态------------");
		//开始读取
		byte[] dst= new byte[bb.limit()];
		bb.get(dst);
		System.out.println("dst="+new String(dst,0,dst.length));
		
		int position3 = bb.position(); // 由于读取数据需要移动指针位置，此处的position值为3 
	    int capacity3 = bb.capacity(); // 缓冲区容量自定义之后便一直不会便；
		int limit3 = bb.limit();   //用于限制读取数据的范围指针位置，限制可读取的范围, 值为3  意思便是  可以读到3 的位置
		
		System.out.println("position3="+position3);
		System.out.println("capacity3="+capacity3);
		System.out.println("limit3="+limit3);
		
		System.out.println("缓冲区开启重复读取模式，未读状态------------");
		bb.rewind();   //开启重复读模式
		int position4 = bb.position(); // rewind()方法会将position清零，重新读取
	    int capacity4 = bb.capacity(); // 缓冲区容量自定义之后便一直不会便；
		int limit4 = bb.limit(); //用于限制读取数据的范围指针位置，限制可读取的范围, 值为3  意思便是  可以读到3 的位置
		
		System.out.println("position4="+position4);
		System.out.println("capacity4="+capacity4);
		System.out.println("limit4="+limit4);
		
		
		System.out.println("缓冲区开启重复读取模式，读取之后状态------------");
		byte[] dst2= new byte[bb.limit()];
		bb.get(dst2);
		int position5 = bb.position();
	    int capacity5 = bb.capacity();
		int limit5 = bb.limit();
		
		System.out.println("position5="+position5);
		System.out.println("capacity5="+capacity5);
		System.out.println("limit5="+limit5);
		System.out.println("dst="+new String(dst2,0,dst2.length));
		
		
		System.out.println("缓冲区重新初始化，未读状态------------");
		bb.clear();  // 重新初始化
		System.out.println("position6="+bb.position()); //clear() 会重新初始化缓冲区到初始化状态，即 position=0 capacity=10 limit=10  但是数据还在
		System.out.println("position6="+bb.capacity());
		System.out.println("position6="+bb.limit());
		
		
		System.out.println("缓冲区重新初始化，读取之后状态------------");
		bb.flip();    //开启读取模式
		System.out.println("position7="+bb.position()); //clear() 会重新初始化缓冲区到初始化状态，即 position=0 capacity=10 limit=10  但是数据还在
		System.out.println("position7="+bb.capacity());
		System.out.println("position7="+bb.limit());
		byte[] dst3= new byte[bb.limit()];
		bb.get(dst3);
		
		System.out.println("position8="+bb.position()); //clear() 会重新初始化缓冲区到初始化状态，即 position=0 capacity=10 limit=10  但是数据还在
		System.out.println("position8="+bb.capacity());
		System.out.println("position8="+bb.limit());
		System.out.println("dst="+new String(dst3,0,dst3.length));
		
	}

}

执行结果：

缓冲区初始化状态------------
position=0
capacity=10
limit=10
缓冲区添加 123 三个字节------------
position1=3
capacity1=10
limit1=10
缓冲区开启读取模式，未读状态------------
position2=0
capacity2=10
limit2=3
缓冲区开启读取模式，读取之后状态------------
dst=123
position3=3
capacity3=10
limit3=3
缓冲区开启重复读取模式，未读状态------------
position4=0
capacity4=10
limit4=3
缓冲区开启重复读取模式，读取之后状态------------
position5=3
capacity5=10
limit5=3
dst=123
缓冲区重新初始化，未读状态------------
position6=0
position6=10
position6=10
缓冲区重新初始化，读取之后状态------------
position7=0
position7=10
position7=0
position8=0
position8=10
position8=0
dst=

该代码实例结合注释可以很好的理解 position,limit 的概念；