以IntBuffer为例,初始化一个Buffer,InputBuffer是一个抽象类,是Buffer的子类:
//初始化buffer,allocate方法用于初始化,参数是缓冲区容量
IntBuffer buffer = IntBuffer.allocate(10);
查看InputBuffer源码:
public static IntBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapIntBuffer(capacity, capacity);
}
可以看到实际返回的是HeapIntBuffer的对象,继续查看HeapIntBuffer源码:
HeapIntBuffer(int cap, int lim) { // package-private
super(-1, 0, lim, cap, new int[cap], 0);
/*
hb = new int[cap];
offset = 0;
*/
}
区中的super调用的是IntBuffer中的构造方法:
IntBuffer(int mark, int pos, int lim, int cap, // package-private
int[] hb, int offset)
{
super(mark, pos, lim, cap);
this.hb = hb;
this.offset = offset;
}
其中几个参数说明如下: cap是capacity,即容量,就是缓冲区的大小
hb是一个数组,是缓冲区实际存储数据的地方,数组大小根据capacity值设定
pos是position,表示位置,是一个标记。表示缓冲区(hb)中当前要读取或写入的数据位置
lim是limit,在写入的时候,它的值和capacity一致,读取的时候,它是缓冲区中数据的实际长度 offset是偏移量 mark是标记
这些参数的作用,具体要看写入和读取的代码 写入数据使用put方法:
//初始化buffer,allocate方法用于初始化,参数是缓冲区容量
IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1
buffer.put(2);//写入数字2
查看HeapIntBuffer中的源码:
public IntBuffer put(int x) {
hb[ix(nextPutIndex())] = x;
return this;
}
可以看到是在hb数组中放入要写入的数字,放入的位置通过nextPutIndex()和ix()两个方法获得:
final int nextPutIndex() { // package-private
if (position >= limit)
throw new BufferOverflowException();
return position++;
}
可以看到,在方法中判断了position和limit的大小,在缓冲区初始化的时候,position是0,limit是缓冲区的大小,如果要放入的索引位置超出了缓冲区大小,就抛出异常。第一个写入的位置position是0,之后position++,即下一次从索引1开始写入。
protected int ix(int i) {
return i + offset;
}
ix()方法用于计算偏移后的位置。因为开始的时候offset=0,所以默认是不偏移的。 对于已经写入得效果,我们可以输出缓冲区中的数组:
System.out.println(Arrays.toString(buffer.array()));
其中array()返回的就是前面说到的数组hb,即缓冲区实际存放数据的地方,源码如下:
public final int[] array() {
if (hb == null)
throw new UnsupportedOperationException();
if (isReadOnly)
throw new ReadOnlyBufferException();
return hb;
}
运行效果如下图: 在array()方法中看到了一个isReadOnly属性,顾名思义,它是设置只读的
查看源码:
public IntBuffer asReadOnlyBuffer() {
return new HeapIntBufferR(hb,
this.markValue(),
this.position(),
this.limit(),
this.capacity(),
offset);
}
asReadOnlyBuffer()方法创建了一个新的HeapIntBufferR(注意后面多了个R,不是原来的HeapIntBuffer了),新缓冲区的属性和当前的对象一致,并且新缓冲区把isReadOnly属性设置成了true
protected HeapIntBufferR(int[] buf,
int mark, int pos, int lim, int cap,
int off)
{
super(buf, mark, pos, lim, cap, off);
this.isReadOnly = true;
}
HeapIntBufferR的put()方法是不能写入的:
public IntBuffer put(int x) {
throw new ReadOnlyBufferException();
}
Buffer是既可以写入,又可以读取的。默认是写入模式。如果想读取已经写入的内容,需要切换读写模式:
IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1,写完之后position是1
buffer.put(2);//写入数字2,写完之后position是2
buffer.flip();//切换到读
while (buffer.hasRemaining()) {
System.out.println(buffer.get());
}
首先看get()方法,get()用于读取缓冲区数组中的元素,每次返回一个元素,查看源码:
public int get() {
return hb[ix(nextGetIndex())];
}
final int nextGetIndex() { // package-private
if (position >= limit)
throw new BufferUnderflowException();
return position++;
}
可以看到返回的是第position个位置的元素。但是position在put()写入的时候记录的是下一次该写入的位置,如果直接从position开始读,是读不到数据的。所以需要flip()方法:
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}
flip()方法中,limit=position,即已经写入的数据长度,设置position=0,之后再读取的时候,就是从索引0开始读的了。每次读取一个元素,position自增1。
public final boolean hasRemaining() {
return position < limit;
}
hasRemainig()中对position和limit进行判断,保证不会读取的数据不会超出写入的部分。
所以capacity>limit>position
因为读取之后,重置了position和limit,所以不能再继续写入了。需要从读模式再切换回写模式:
从写切换到读有两个方法,clear()和compact()
//初始化buffer
IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1
buffer.put(2);//写入数字2
buffer.flip();//切换到读
System.out.println(buffer.get());//读取的是数字1,数字2未读取
System.out.println("===================");
//buffer.clear();//切换到写模式,后写入的数据覆盖原来的内容
buffer.compact();//切换到写模式,不清除未读取的数据
buffer.put(3);
buffer.put(4);
buffer.flip();//切换到读
while (buffer.hasRemaining()) {
System.out.println(buffer.get());
}
上面的代码,用clear()之后,输出第二次读取输出的是34,2被后写入的3覆盖了;用compact(),第二次输出的是234,因为2没有被读取,被保留,3和4会在它之后写入。
clear()方法之后,position=0,写入的数据会覆盖以前的数据;而compact()方法会保留未读的数据(注意只是未读的,已经写入的数据如果读取过了就不会保留)。
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
public IntBuffer compact() {
System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
position(remaining());
limit(capacity());
discardMark();
return this;
}
public final int remaining() {
return limit - position;
}
clear()方法比较直观,把position重置为0,下次就从索引0开始写入,所以后写入的数据会覆盖原来位置的数据。
compact()方法里,可以看到这里调用了一个数组复制的方法,查看几个参数的意义:
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
src是原始数组,srcPos是从原始数组的第几个位置开始复制,desc是目标数组,destPos是目标数组开始写入的位置,length是从原始数组中复制几个元素到目标数组中。
在读取模式的时候,position是读取的位置,limit是一共有多少数据,remaining()中limit-position就是还有几个是没有读取的。
复制数组的之后,从position开始复制,到新数组,一共复制remaining个,就是把没有读取的数据都复制到新数组去,destPos=0,就是从新数组的索引0开始插入。所以compact()方法是把原来缓冲区中没有读取的数据全部放放到新缓冲区的头部,新插入的数据在头部之后。
通过上面的案例可以看出,所谓的读模式和写模式,就通过改变position和limit的值,对数组中指定位置的元素进行操作。
另外两个和position方法,mark()和reset(),mark()用于记录当前position,reset()可以将position恢复到mark()记录的值。
IntBuffer buffer = IntBuffer.allocate(10);
buffer.put(1);//写入数字1
buffer.put(2);//写入数字2
buffer.mark();//对position进行标记,当前mark=2
System.out.println("get之前:"+buffer.position());//2
System.out.println(buffer.get());//输出0,position++,position=3
System.out.println("get之后:"+buffer.position());//3
buffer.reset();//重置position,position等于mark标记值2
System.out.println("reset之后:"+buffer.position());//2
FileChannel写文件:
FileOutputStream outputStream = new FileOutputStream("G:/file_channel.txt");
FileChannel channelOut = outputStream.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
String string = "你好";
buffer.put(string.getBytes());
buffer.flip(); // 切换到读模式
channelOut.write(buffer); //把buffer中的数据写入channel
channelOut.close();
outputStream.close();
java1.7之后提供的新的打开FileChannel的方式:
FileChannel channel = FileChannel.open(Paths.get("D://test.txt"), StandardOpenOption.CREATE,StandardOpenOption.WRITE);
注意在调用channel的write方法之前必须调用buffer的flip方法,否则无法正确写入内容 FileChannel读文件:
FileInputStream inputStream = new FileInputStream("G:/ip.txt");
FileChannel channelIn=inputStream.getChannel();
ByteBuffer buf = ByteBuffer.allocate(128);
int len=-1;
while((len=channelIn.read(buf))!=-1){
buf.flip();//从写模式切换到读模式
byte[] arr = new byte[len];
buf.get(arr, 0, len); //讲buffer中的数据写入arr
System.out.println(new String(arr,"GBK"));
buf.compact();//让Buffer准备再次写入
}
channelIn.close();
inputStream.close();
java1.7之后提供的新的打开FileChannel的方式:
FileChannel channel = FileChannel.open(Paths.get("D://test.log"), StandardOpenOption.READ);
使用FileChannel复制文件:
FileInputStream fileInputStream = new FileInputStream("G:/java.zip");
FileOutputStream fileOutputStream = new FileOutputStream("G:/java2.zip");
// 得到fileInputStream的文件通道
FileChannel fileChannelInput = fileInputStream.getChannel();
// 得到fileOutputStream的文件通道
FileChannel fileChannelOutput = fileOutputStream.getChannel();
// 将fileChannelInput通道的数据,写入到fileChannelOutput通道
fileChannelInput.transferTo(0, fileChannelInput.size(), fileChannelOutput);
fileInputStream.close();
fileChannelInput.close();
fileOutputStream.close();
fileChannelOutput.close();
transferTo方法文件大小限制在2G以内,可以直接使用缓冲区,不受限制。
FileChannel in = FileChannel.open(Paths.get("D://test.log"), StandardOpenOption.READ);
FileChannel out = FileChannel.open(Paths.get("D://test.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (in.read(buffer) != -1) {
buffer.flip();//从写模式切换到读模式
out.write(buffer);
buffer.clear();//让Buffer准备再次写入
}
out.close();
in.close();