尚硅谷NIO学习之---基础及缓冲区Buffer

目录

1.NIO-基础及缓冲区Buffer

2.NIO-管道

2.NIO-选择器

NIO基础及缓冲区Buffer

一.NIO基础

在Java中，NIO读写是I/O的基本过程。 从通道读取：创建一个缓冲区，然后请求通道读取数据。通道写入：创建一个缓冲区，填充数据，并要求通道写入数据。
读写操作中使用的核心部件有：

• Channels
• Buffers
• Selectorshttps://blog.csdn.net/loveyour_1314/article/details/100185811
  Java NIO还有其它更多的组件和类，但是Channel，Buffer和Selector用作API的核心。

NIO类和包

包名称	包的作用
java.nio	它是NIO系统的顶级包，NIO系统封装了各种类型的缓冲区。
java.nio.charset	它封装了字符集，并且还支持分别将字符转换为字节和字节到编码器和解码器的操作。
java.nio.channels	它支持通道，这些通道本质上是打开I/O连接。
java.nio.file	它支持文件系统的服务提供者

1.NIO 和IO的区别

IO	NIO
面向流(Stream Oriented)	面向缓冲区(Buffer Oriented)
阻塞IO(Blocking IO)	非阻塞IO(Non Blocking IO)
无	选择器（Selector）

---

二.缓冲区（Buffer）

分类

直接与非直接缓冲区

• 字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在
  机 此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），
  虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。

• 直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法 来创建。此方法返回的 缓冲区进行分配和取消
  分配所需成本通常高于非直接缓冲区 。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对
  应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的
  机 本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好
  处时分配它们。

• 直接字节缓冲区还可以过 通过FileChannel 的 map() 方法 将文件区域直接映射到内存中来创建 。该方法返回
  MappedByteBuffer 。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区
  中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在
  访问期间或稍后的某个时间导致抛出不确定的异常。

• 字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在
  性能关键型代码中执行显式缓冲区管理

  非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中
  直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率

直接缓冲区

非直接缓冲区

缓冲区类型（基本数据类型除了boolean全都有一个对应类型）**

获取Buffer对象:

static XxxBuffer allocate(int capacity) : 创建一个容量为capacity 的 XxxBuffer 对象
例如：ByteBuffer buf = ByteBuffer.allocate(1024);

Buffer中常用方法：

方法	描 述
ByteBuffer put((byte b)	将给定单个字节写入缓冲区的当前位置
ByteBuffer put(byte[] src)	将 src 中的字节写入缓冲区的当前位置
ByteBuffer put(int index, byte b)	将指定字节写入缓冲区的索引位置(不会移动 position)
ByteBuffer get()	读取单个字节(返回的为字节，想看的话需要把字节转换为char或者String,下同)
ByteBuffer get(byte[] dst)	批量读取多个字节到 dst 中
ByteBuffer get(int index)	读取指定索引位置的字节(不会移动 position)
Buffer clear()	清空缓冲区并返回对缓冲区的引用
Buffer flip() 为	将缓冲区的界限设置为当前位置，并将当前位置充值为 0
int capacity()	返回 Buffer 的 capacity 大小
boolean hasRemaining()	判断缓冲区中是否还有元素
int limit()	返回 Buffer 的界限(limit) 的位置
Buffer limit(int n)	将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
Buffer mark()	对缓冲区设置标记
int position()	返回缓冲区的当前位置 position
Buffer position(int n)	将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
int remaining()	返回 position 和 limit 之间的元素个数
Buffer reset()	将位置 position 转到以前设置的 mark 所在的位置
Buffer rewind()	将位置设为为 0， 取消设置的 mark

缓冲区的基本属性:

• 容量 (capacity) ：表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创
  建后不能更改。
• 限制 (limit) ：第一个不应该读取或写入的数据的索引，即位于 limit 后的数据
  不可读写。缓冲区的限制不能为负，并且不能大于其容量。
• 位置 (position)： ：下一个要读取或写入的数据的索引。缓冲区的位置不能为
  负，并且不能大于其限制 (即缓冲区中正在操作数据的位置)
• 标记 (mark) 与重置 (reset) ：标记是一个索引，通过 Buffer 中的 mark() 方法
  指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这
  个 position.

标记 、位置 、限制 、容量遵守以下不变式：
0 <= mark <= position <= limit <= capacity

缓冲区的数据操作

将数据放入数据到 Buffer 中

put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)

获取 Buffer 中的数据

get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)

    String str = "abcde";
	
	//1. 分配一个指定大小的缓冲区
	ByteBuffer buf = ByteBuffer.allocate(1024);
	System.out.println("-----------------allocate()----------------");
	System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());;
	//  0 1204 1024
	
	//2. 利用 put() 存入数据到缓冲区中
	buf.put(str.getBytes());
	System.out.println("-----------------put()----------------");
	System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());;
	// 5 1204 1204
	
	//3. 切换读取数据模式
	buf.flip();
	System.out.println("-----------------flip()----------------");
	System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());;
	//0 5 1024
	
	//4. 利用 get() 读取缓冲区中的数据
	byte[] dst = new byte[buf.limit()];
	buf.get(dst);
	System.out.println(new String(dst, 0, dst.length));
	 // abcde
	System.out.println("-----------------get()----------------");
	System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());;
    //5 5 1204
    
	//5. rewind() : 可重复读
	buf.rewind();
	System.out.println("-----------------rewind()----------------");
	System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());;
	// 0 5 1024
	
	//6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
	buf.clear();
	System.out.println("-----------------clear()----------------");
	System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());;
	// 0 1024 1024
	System.out.println((char)buf.get());
   //a

原理如下：

   	String str = "abcde";
		ByteBuffer buf = ByteBuffer.allocate(1024);

		//1.向缓冲区放入字节
		buf.put(str.getBytes());
		System.out.println(buf.position());//5
		/**
		 * 缓冲区的界限(limit)设置为当前位置，并将当前位置(position)重置为0
		 * 源码：
		 * public final Buffer flip() {
		 *         limit = position;
		 *         position = 0;
		 *         mark = -1;
		 *         return this;
		 *     }
		 */
		//2.切换读取数据模式
		buf.flip();
		System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());
		// position:0   limit:5   capacity:1024

		//3.读取字节1
		byte[] dst = new byte[buf.limit()];
		// 批量读取多个字节到 dst 中
		/**
		 * 源码：
		 *   public ByteBuffer get(byte[] dst) {
		 *         return get(dst, 0, dst.length);
		 *     }
		 */
		buf.get(dst);
		System.out.println(new String(dst)); //abcde
		System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());
		// position:5   limit:5   capacity:1024
		buf.flip();
		System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());
		// position:0   limit:5   capacity:1024
		3.读取字节2
		byte[] dst1 = new byte[buf.limit()];
		//第二个参数知识放入dst1的起始位置,第三个位置为放进dst1的长度
		buf.get(dst1,0, 2);
		System.out.println(new String(dst1)); //ab口口口 说明只有前2位有数据
		System.out.println(new String(dst1,0,2)); //ab(去掉口口口)

		System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());
		//position:2   limit:5   capacity:1024

		//4.mark() : 标记
		buf.mark();
		//buf.get()不加参数代表从position后只取出一个字节
		System.out.println((char) buf.get()); // c

		System.out.println("position:"+buf.position() +"   limit:"+buf.limit() +"   capacity:"+buf.capacity());
		// position:3   limit:5   capacity:1024
	
		byte[] dst2 = new byte[buf.limit()];
		buf.get(dst2,1, 2);
		System.out.println(new String(dst2)); //口de口口

		//如果上面的代码改为 buf.get(dst2, 0, 3);就会抛出java.nio.BufferUnderflowException的异常
		// ，因为当前的position已经为3了，如果往后取出大于3个字节便会超过Limit

		//reset() : 恢复到 mark 的位置
		buf.reset();
		System.out.println(buf.position());//2

		//判断缓冲区中是否还有剩余数据
		if(buf.hasRemaining()){

			//获取缓冲区中可以操作的数量
			System.out.println(buf.remaining());//3
		}

Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。
》》》简而言之，Channel 负责传输， Buffer 负责存储

---

参考：

尚硅谷谷粒学院

易百教程

并发编程网

https://blog.csdn.net/zhoudatianchai/article/details/82880908