Buffer 有3个重要的参数：位置(position)、容量(capactiy)、上限(limit)
位置(position): 写：当前缓冲区的位置，将从position的下一个位置写数据。 读：当前缓冲区的读取的位置，将从此位置后，读取数据。
容量(capactiy): 写：缓冲区的总容量上限。 读：缓冲区的总容量上限。
上限(limit): 写：缓冲区的实际上限，它总是小于等于容量。通常情况下，和容量相等。 读：代表可读取的总容量，和上次写入的数据量相等。
public static void main(String[] args) {
ByteBuffer b = ByteBuffer.allocate(15);//15字节大小的缓冲区
System.out.println(b);//[pos=0 lim=15 cap=15]
for (int i = 0; i < 10; i++) {
b.put((byte) i);//存入10字节数据
}
//pos=10 为下一个即将输入的位置
System.out.println(b); //[pos=10 lim=15 cap=15]
b.flip();//重置position 通常将Buffer从写模式转换为读模式需要执行此方法
//flip()不仅重置了当前position为0，还将limt设置到当前的position的位置，
//这样做的目的是防止在读模式中,读到应用程序根本没有进行操作的区域。
System.out.println(b);//[pos=0 lim=10 cap=15]
for (int i = 0; i < 5; i++) {
System.out.print(b.get()); //
}
System.out.println();
//执行5次读操作，和写操作一样，读操作也会将position设置到当前位置
System.out.println(b); //[pos=5 lim=10 cap=15]
b.flip();
System.out.println(b);//[pos=0 lim=5 cap=15]
//////////////////////////////////////////////////
/**
* 1.Buffer的创建
*/
//从堆中分配缓冲区
//ByteBuffer buffer = ByteBuffer.allocate(1024);
//从既有数组中创建
byte[] array = new byte[1024];
ByteBuffer buffer = ByteBuffer.wrap(array);
System.out.println("------------------------------------");
/**
* 2.重置和清空缓冲区
* 重置 ：指重置了Buffer各项标志位，并不是真正清空了Buffer内容。
* 它的作用在于为提取Buffer的有效数据做准备。
*
* rewind() //将position置零，并清除标志位(mark)
* out.wirte(buf);//从Buffer读取数据到Channel
* buf.rewind(); //回滚Buffer
* buf.get(array); //将Buffer的有效数据复制到数组中。
*
* clear() //将position置零,同时将limit设置为capacity的大小，并清除了标志mark.
* 由于清空了limit 便无法得知Buffer内那些数据是真实有效的，这个方法用于为重新写Buffer做准备。
* buf.clear(); //为读入数据到Buffer做准备
* in.read(buf); //从通道读入数据
*
* flip() //将limit设置到position所在位置，然后将position置零，并清除标志位mark,通常在读写转换时使用。
* buf.put(magic); //将magic数组写入Buffer
* in.read(buf); //从通道读入给定数据，存放到Buffer中
* buf.flip(); //将Buffer从读状态转换为写状态
* out.write(buf); //将magic和in通道中读入数据，写到通道out中。
*/
/**
* 3.标志(mark)缓冲区
* 可以随时记录当前位置，然后在任意时刻回到这个位置，加快或简化数据处理流程
*
* mark() //记录当前位置。
* reset() //用于恢复到mark所在的位置。
*/
ByteBuffer bb= ByteBuffer.allocate(15);
for (int i = 0; i < 10; i++) {
bb.put((byte) i);
}
System.out.println(bb);
bb.flip();//准备读
for (int i = 0; i < bb.limit(); i++) {
System.out.print(bb.get());
if(i == 4){
bb.mark(); //在第四个位置做mark
System.out.println("\nmark at "+ i);
}
}
bb.reset();//回到mark位置 并处理后续数据
System.out.println("\nreset to mark");
while(bb.hasRemaining()){//后续所有数据将被处理
System.out.print(bb.get());
}
System.out.println();
System.out.println("----------------------------------");
/**
* 4.复制缓冲区
*
* duplicate() //以源缓冲区为基础，生成一个完全一样的新缓冲区，会共享相同的内存数据，任意一方数据改动都是相互可见的。
* 两者独立维护了各自的position、limit、mark.
*
*/
ByteBuffer b1 = ByteBuffer.allocate(15);
for (int i = 0; i < 10; i++) {
b1.put((byte) i);
}
ByteBuffer cp = b1.duplicate();//复制当前缓冲区
System.out.println(b1); //[pos=10 lim=15 cap=15]
System.out.println(cp); //[pos=10 lim=15 cap=15]
cp.flip(); //重置缓冲区cp
System.out.println(b1); //[pos=10 lim=15 cap=15]
System.out.println(cp); //[pos=0 lim=10 cap=15]
cp.put((byte) 100); //向缓冲区cp存入数据
//数据是共享的
System.out.println("b1="+b1.get(0)); //b1=100
System.out.println("cp="+cp.get(0)); //cp=100
System.out.println("-----------------------------------");
/**
* 5.缓冲区分片
*
* slice() //在现有缓冲区中，创建新的子缓冲区，子缓冲区和父缓冲区共享数据。
* 缓冲区切片可以将一个大缓冲区进行分割处理，得到的子缓冲区都具有完整的缓冲区模型结构
*/
ByteBuffer b2 = ByteBuffer.allocate(15);
for (int i = 0; i < 10; i++) {
b2.put((byte) i);
}
System.out.println(b2);
b2.position(2);
b2.limit(6);
ByteBuffer subBuf = b2.slice();// 生成子缓冲区
System.out.println(b2); //[pos=2 lim=6 cap=15]
System.out.println(subBuf); //[pos=0 lim=4 cap=4]
for (int i = 0; i < subBuf.capacity(); i++) {
byte bb2 = subBuf.get(i);
bb2 *= 10; //在子缓冲区中，每个元素都剩以10
subBuf.put(i, bb2);
}
b2.position(0);
b2.limit(b2.capacity()); //重置父缓冲区， 并查看父缓冲区的数据
System.out.println(b2);
while(b2.hasRemaining())
System.out.print(b2.get() + " ");
System.out.println();
System.out.println("--------------------------------------");
/**
* 6.只读缓冲区
* asReadOnlyBuffer() //得到一个与当前缓冲区一致，并且共享内存数据的只读缓冲区。
* 可保证核心数据安全，不被随意篡改。原始缓冲区的数据修改，只读缓冲区也是可见的。
*
*/
ByteBuffer b3 = ByteBuffer.allocate(15);
for (int i = 0; i < 10; i++) {
b3.put((byte) i);
}
ByteBuffer readOnly = b3.asReadOnlyBuffer(); //创建只读缓冲区
System.out.println(readOnly);
readOnly.flip();
while(readOnly.hasRemaining())
System.out.print(readOnly.get()+ " ");
System.out.println();
b3.put(2,(byte) 20);//修改原始缓冲区数据
//readOnly.put(2, (byte)20); //修改只读缓冲区 会抛出异常 java.nio.ReadOnlyBufferException
readOnly.flip();
while(readOnly.hasRemaining())
System.out.print(readOnly.get()+ " "); //新改动在只读缓冲区可见
System.out.println();
/**
* 7.文件映射到内存
* FileChannel.map(); //它比常规的基于流的I/O快很多
*/
RandomAccessFile raf;
try {
raf = new RandomAccessFile("a.txt", "rw");
FileChannel fc = raf.getChannel();
//将文件映射到内存
MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, raf.length());
/*while(mbb.hasRemaining())
System.out.println(mbb.get());
*/
mbb.put(0,(byte) 98); //修改文件
raf.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("--------------------------------------------------");
/**
* 8.处理结构化数据，散射(Scattering)和聚集(Gathering)
*
* 散射(Scattering): 值将数据读入一组Buffer中，而不仅仅是一个。
* 聚集(Gathering): 聚集与之相反，将数据写入一组Buffer中。
*
* 在散射读取中，通道依次填充每个缓冲区，填满一个缓冲区后，就开始填充下一个。缓冲区数组就是一个大缓冲区
*/
String Path = "D://a.txt";
try {
//通过聚集写操作创建该文件
ByteBuffer bookBuf = ByteBuffer.wrap("Java性能优化技巧".getBytes("utf-8"));
ByteBuffer autBuf = ByteBuffer.wrap("葛一鸣".getBytes("utf-8"));
int booklen = bookBuf.limit();//记录长度
int authlen = autBuf.limit();
ByteBuffer[] bufs = new ByteBuffer[]{bookBuf,autBuf};
File file = new File(Path);
if(!file.exists())
file.createNewFile();//不存在则创建文件
FileOutputStream fos = new FileOutputStream(file);
FileChannel fc = fos.getChannel();
fc.write(bufs);//聚集写文件
System.out.println("写入数据成功");
fos.close();
//使用散射读取文件
ByteBuffer b4 = ByteBuffer.allocate(booklen);//根据实际信息构造Buffer
ByteBuffer b5 = ByteBuffer.allocate(authlen);
ByteBuffer[] bufss = new ByteBuffer[]{b4, b5}; //Buffer数组
File f = new File(Path);
FileInputStream fis = new FileInputStream(f);
FileChannel fcl = fis.getChannel();
fcl.read(bufss);//读入数据
String bookName = new String(bufss[0].array(), "utf-8");//取得数据
String authName = new String(bufss[1].array(), "utf-8");//取得数据
System.out.println(bookName + authName);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}