Buffer 是java NIO中三个核心概念之一 缓存, 在java的实现体系中Buffer作为顶级抽象类存在
简单说,Buffer在做什么?#
我们知道,在java IO中体系中, 因为InputStream和OutputStream是抽象类,而java又不可以多重继承,于是任何一个流要么只读,要么只写.而无法完成同时读写的工作
于是: Buffer来了
NIO中,对数据的读写,都是在Buffer中完成的,也就是说,同一个buffer我们可以先读后写, 它底层维护着一个数组,这个数组被三个重要的属性控制,有机的工作结合,使buffer可读可写;
此外,Buffer是线程不安全的,并发访问需要同步
三个重要属性:#
- capacity: 容量
- Buffer中元素的个数
- 永远不能为负数
- 永远不会变化
- limit: 限制
- 实际上它是Buffer所维护的那个数组中的一个下标
- limit是第一个不能被读,或者第一个不能被写的元素的index
- limit永远不会是负数
- 永远不会超过capacity
- Position: 定位
- 指数组中下一个将要被读或者将要被写的元素的索引
图解,Buffer是如何维护的数组#
一开始: 我们初始化它的大小为6 初始状态,Capacity和Limit都在最后一个不能被读或者不能被写的位置上
接着我们读入两个数据.position跳转到下一个将被读的index
接下来,准备写把buffer中的数据写出去两个, 于是我们需要反转数值
buffer.flip();
反转的逻辑:
limit=position; position=0;
于是从0写 ,写到哪个位置? 写到limi前
#
写完毕后:如下图:
现在可以看到,pisition == limit
如果再想读入新的数据,同样需要反转数据flip()
但是此时,limit仍然是刚刚position的所在的最后的位置#
Buffer架构体系:#
模拟Buffer实现一个相同的继承体系,进一步了解成员变量在他们之间是怎么维护的
首先,和Buufer等级一样的顶级父类
public abstract class ParentSupper { private int position; private int capacity; ParentSupper(int position,int capacity){ this.position=position; this.capacity=capacity; System.out.println("ParentSupper 的构造方法执行了... "); } final int nextPutIndex(){ if (position>=capacity){ throw new RuntimeException("索引异常"); } return position++; } int i=0; final int nextGetIndex(){ if (i >=position){ throw new RuntimeException("索引异常"); } return i++; } }
接着是它的实现类, 和IntBuffer 等级一样
public abstract class Parent extends ParentSupper { // 抽象类中的成员变量,必须放在构造方法中 final int[] arr1; int tag; // todo 执行父类的构造方法 Parent(int a, int[] arr1) { // 调用父类的构造函数 super(0,a); this.arr1 = arr1; this.tag = a; } // 构造器 public static Parent allocate(int capacity) { return new Child(capacity); } // 抽象的方法 public abstract int get(); public abstract void put(int number); }
作为抽象类的它,有自己的抽象方法, get put, 同时它里面维护着 核心数组, final不可变类型的, 抽象类中的变量不能单独存在,必须依附构造函数,于是我们添加它的构造函数
再就是它的实现类:
class Child extends Parent { public Child(int capacity) { super(capacity,new int[capacity]); } // todo 重写父类的构造方法 @Override public int get() { return arr1[nextGetIndex()]; } @Override public void put(int num) { arr1[nextPutIndex()]=num; } }
注意,Child的类上并没有public 修饰,意味着他只是可以包内访问
下面测试:
public class text { public static void main(String[] args) { // 初始化 Parent allocate = Parent.allocate(9); for (int i=0;i<9;i++){ allocate.put(i); } for (int i=0;i<=8;i++){ System.out.println( allocate.get()); } } }
运行流程是怎样的呢?
当我们使用
Parent.allocate(10);创建对象时,底层确实 new Child(int i), 同时把传递给Child, 而在Child()相应的构造函数中,接着调用的是spuer()方法,同时把10 传递给super也就是Parent,同时实例化了Parent的 数组, 在Supper的构造方法中,把0,和传递进来的10 传递给了SuperParent, 让他维护两个值
思考, 各个部分之间的作用
- Buffer : 维护着当前数据的 position limit 和 capaciy值,这是数组的下标值,但是Buffer却没有数组
- Buffer的直接实现类,如IntBuffer , 依然是抽象类, 它有数组作为缓存, 数组的维护它交给了它的父类Buffer, 针对数组的初始化,读写,他交给了自己的实现类
数组的维护工作是一样的,所以抽象成Buffer
- HeapIntBuffer: 它继承了IntBuffer, 同时把它的父类的数组进行了实例化,并且重写了父类的get put方法
不同类型的数据,具体的读写是有区别的,所有抽象成不同的子类
在回去看,allocate(); 显然我们得到的是最外层的子类对象,这也就意味着他是最强的那个对象,它拥有父类的数据,并且这个数据的读写由它的爷爷替自己把关,这就是Buffer的设计模式
Buffer中常见的API#
Buffer的所有子类全部定义了两套关于get() 和 put()的方法#
- Relative: 相对的读写, 相对的读写都是从当前的position的位置开始,每次的get/put都会是position的位置发生改变
- Avsolute: 绝对的读写 , 用户指定索引, 从指定的索引里面get,或者直接往指定的索引里面put
clear()#
将buffer置为初始状态的值,实际上就是让新读入buffer中的值,覆盖掉原来的值
position=0; limit=capacity;
flip()#
反转buffer
limit = position; positon=0;
isReadOnly()#
判断是否是只读的buffer
分片Buffer#
//限制前后 准备切片 byteBuffer.position(2); byteBuffer.limit(6); // 切片 ByteBuffer slice = byteBuffer.slice();
新得到的buffer和原buffer共享内存空间
类型化的Buffer#
ByteBuffer allocate = ByteBuffer.allocate(123); allocate.putInt(1); allocate.putChar('你'); allocate.putDouble(123.123123); allocate.putShort((short) 2); allocate.putLong(3L); allocate.flip(); System.out.println(allocate.getInt()); System.out.println(allocate.getChar()); System.out.println(allocate.getDouble()); System.out.println(allocate.getShort()); System.out.println(allocate.getLong());
类型化 的put和get 但是呢!!! 怎么存进去的 就得怎么取出来 , 否者会出现乱码
NIO拷贝文件#
// 获取输入流 FileInputStream fileInputStream = new FileInputStream("123.txt"); FileOutputStream fileOutputStream = new FileOutputStream("output123.txt"); // 获取一个通道,关联上数据 FileChannel channel = fileInputStream.getChannel(); FileChannel outputStreamChannel = fileOutputStream.getChannel(); ByteBuffer byteBuffer = ByteBuffer.allocate(128); while (true) { // todo 每次读满一次缓存后, 重新初始化buffer byteBuffer.clear(); // 将数据读入 缓存 int read = channel.read(byteBuffer); System.out.println("read == "+read); if (read == -1) { break; } // 反转 limit=position position=0 byteBuffer.flip(); // 通过channel 往输出流中写入缓存的数据 outputStreamChannel.write(byteBuffer); } // 释放资源 fileInputStream.close(); fileInputStream.close(); System.out.println("结束..."); }
每次循环一开始,都要重置buffer,否则第一轮读取结束之后, limit==position 从而channel里面新的数据读不进去,而 limit==position也不会引发异常,随后的flip()将buffer反转,position为0, 使得当前buffer中的数据被循环写到文件中,成为死循环
