2.Buffer 缓冲区

/*缓冲区（Buffer）*/

Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同（boolean 除外），有以下Buffer常用子类：

/*ByteBuffer*/（常用） 、CharBuffer 、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer

上述Buffer 类，他们都采用相似的方式进行管理数据，只是各自管理的数据类型不同而已。都是通过如下方法获取一个Buffer对象：

　　static XxxBuffer allocate（int capacity）: 创建一个容量为 capacity 的 XxxBuffer对象

/*缓存区的基本属性*/

Buffer中的重要概念：

　　1.容量（capacity）：表示Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能修改 （创建Buffer对象时 初始化）

　　2.限制（limit）：第一个不应该读取或写入的数据的索引，（即位于limit后的数据不可读写）缓冲区的限制 不能为负，并且不能大于其容量

　　3.位置（position）：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制值

　　

　　4.标记（mark）与重置（reset）：标记也是一个索引，通过Buffer中的 mark() 方法指定Buffer中一个特定的position，之后可以通过调用reset（）方法恢复到这个 position

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

Buffer的常用方法

　　Bufffer clear() 清空缓冲区（索引重置为初始状态）并返回对缓冲区的引用（但是缓冲区的数据依然存在，但是出于 “被遗忘” 状态）

　　Buffer flip() 将缓冲区的界限设置为当前位置，并将当前位置重置为0 （即准备开始操作缓冲区里面的数据）

缓冲区的数据操作

　　Buffer 所有子类提供了 两个用于数据操作的方法： get() 与 put() 方法

/*直接与非直接缓冲区*/

　　非直接缓冲区：通过allocate() 方法 分配缓冲区，将缓冲区建立在 JVM内存中

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

字节缓冲区要么是直接的，要么是非直接的。如果是直接字节缓冲区，则Java 虚拟机 会尽最大努力直接在此缓冲区上执行本机 I/O 操作

即直接缓冲区： 通过过一个 ‘物理内存映射文件’ ，将本来要放在JVM内存中的缓冲区 直接放到 物理内存中

非直接缓冲区： 将缓冲区 先放到JVM 的内存中，然后通过 copy ，将内容复制到 内核地址空间（物理内存） ，写入磁盘

直接缓冲区少了一个 copy 的过程，自然速度会更快，但是也有缺点：1.直接在物理内存上开辟和销毁空间的代价很大，2.基本上失去了对缓冲区数据的控制，无法控制其销毁

所以：仅在直接缓冲区能在程序性能方面带来明显好处时分配他们

 /*
  * 一、缓冲区（Buffer）：在Java NIO中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
  *
  * 根据数据类型不同 （boolean 除外），提供了相应类型的缓冲区
  * ByteBuffer（常用） 、CharBuffer、ShortBuffer等
  *
  * 上述缓冲区 的 管理方式几乎一致，通过 allocate() 获取缓冲区
  *
  * 二、缓冲区存取数据的两个核心方法：
  * put():存入 数据到缓冲区
  * get():获取缓冲区的数据
  *
  * 三、缓冲区的四个核心属性
  * 1.capacity : 容量，表示Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能修改  （创建Buffer对象时 初始化）
  *
  * 2.限制（limit）：第一个不应该读取或写入的数据的索引，（即位于limit后的数据不可读写）
                              缓冲区的限制 不能为负，并且不能大于其容量
    3.位置（position）：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制值                         
 
    4.标记（mark）与重置（reset）：标记也是一个索引，通过Buffer中的 mark() 方法指定Buffer中一个特定的position，
         之后可以通过调用reset（）方法恢复到这个 position
  *
  *  0 <= mark <= position <= limit <= capacity
  *
  *  四、直接缓冲区 和 非直接缓冲区
  *  非直接缓冲区：通过allocate() 方法 分配缓冲区，将采取建立在 JVM内存中
  *  直接缓冲区：通过 allocateDirect() 方法 分配直接缓冲区，将缓冲区建立在物理内存中，可以提高效率
  *
  * */
 
 public class TestBuffer {
 
     @Test
     public void test3() {
         ByteBuffer buffer1 = ByteBuffer.allocateDirect(1024);
         System.out.println(buffer1.isDirect());
         ByteBuffer buffer2 = ByteBuffer.allocate(1024);
         System.out.println(buffer2.isDirect());
     }
 
     @Test
     public void test2() {
         String str = "abcd";
         ByteBuffer buffer = ByteBuffer.allocate(1024);
 
         buffer.put(str.getBytes());
 
         buffer.flip();
 
         byte[] bytes = new byte[buffer.limit()];
         buffer.get(bytes,0,2);
 
         //position = 2
         System.out.println(new String(bytes));
         System.out.println(buffer.position());
 
         //标记当前 position
         buffer.mark();
 
         //position = 4
         buffer.get(bytes,2,2);
         System.out.println(new String(bytes));
         System.out.println(buffer.position());
 
         //将 position reset 到 标记的位置  position = 2
         buffer.reset();
         System.out.println(buffer.position());
     }
 
     @Test
     public void test1() {
         //1.分配一个指定大小的缓冲区
         ByteBuffer buffer = ByteBuffer.allocate(1024);
         System.out.println("-------------allocate()-------------");
         System.out.println(buffer.position());
         System.out.println(buffer.limit());
         System.out.println(buffer.capacity());
 
         //2.利用 put() 存入数据到缓冲区
         String str = "abcedf";
         buffer.put(str.getBytes());
         System.out.println("-------------put()-------------");
         System.out.println(buffer.position());     //此时 位置 索引会变成6，即下一个要读取或写入的数据的索引 是 6 （byte[6]）
         System.out.println(buffer.limit());
         System.out.println(buffer.capacity());
 
         //3.使用 get() 读取数据之前，需要调用 flip() 方法，切换到 读取数据模式 (将position置为0，limit置为原先position)
         //不然按照现在的所以 是无法读取到任何数据的
         buffer.flip();
         System.out.println("-------------flip()-------------");
         System.out.println(buffer.position());
         System.out.println(buffer.limit());
         System.out.println(buffer.capacity());
 
         //4.利用 get() 读取缓冲区中的数据
         //读取 需要创建一个容器去装
         byte[] bytes = new byte[buffer.limit()];
         //将读取到的数据 放到 这个 byte数组中
         buffer.get(bytes);
 
         System.out.println("-------------get()-------------");
         System.out.println(buffer.position());
         System.out.println(buffer.limit());
         System.out.println(buffer.capacity());
         System.out.println(new String(bytes,0,bytes.length));
 
         //5.rewind() 可重复读  将位置设成 0 ，取消设置的 remark，现在就可以重新读取了
         buffer.rewind();
         System.out.println("-------------rewind()-------------");
         System.out.println(buffer.position());
         System.out.println(buffer.limit());
         System.out.println(buffer.capacity());
 
         //6.clear()  清空缓存区，缓冲区中的数据依然存在，但是 处于 ‘被遗忘’状态
         buffer.clear();
         System.out.println("-------------clear()-------------");
         System.out.println(buffer.position());
         System.out.println(buffer.limit());
         System.out.println(buffer.capacity());
 
         System.out.println((char)buffer.get());
     }
 }