Java NIO（New IO或 Non Blocking IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
java IO 与 java NIO 的区别
一、通道（Channel）与缓冲区（Buffer）
若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。简而言之，Channel 负责传输， Buffer 负责存储。
1、缓冲区（Buffer）
缓冲区（Buffer） ：一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。
Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。
Buffer 的常用方法
非直接缓冲区
直接缓冲区
/*
* 一、缓冲区（Buffer）：在java NIO 中负者数据的存储。缓冲区就是数组。用于存储不同类型的数据。
*
* 根据数据类型的不同(boolean 除外)，有以下 Buffer 常用子类：
* ByteBuffer
* CharBuffer
* ShortBuffer
* IntBuffer
* LongBuffer
* FloatBuffer
* DoubleBuffer
*
* 上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区
*
* 二、缓冲区存取数据的两个核心方法：
* put():存入数据到缓冲区中
* put(byte b)：将给定单个字节写入缓冲区的当前位置
* put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
* put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)
* get():获取缓存区中的数据
* get() ：读取单个字节
* get(byte[] dst)：批量读取多个字节到 dst 中
* get(int index)：读取指定索引位置的字节(不会移动 position)
*
* 三、缓冲区中的四个核心属性：
* capacity：容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
* limit：界限，表示缓冲区中可以操作数据的大小。(limit后数据不能进行读写)
* position：位置，表示缓冲区中正在操作数据的位置。
* mark:标记，表示记录当前position位置。可以通过reset()恢复到mark的位置。
*
* 0<=mark<=position<=limit<=capacity
*
* 四、直接缓冲区与非直接缓冲区：
* 非直接缓冲区：通过allocate()方法分配缓冲区，将缓冲区建立在JVM的内存中。
*
* 直接缓冲区：通过allocateDirect()方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率
* 此方法返回的 缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区 。
* 直接缓冲区的内容可以驻留在常规的垃圾回收堆之外.
* 将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。
* 最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
* 直接字节缓冲区还可以过 通过FileChannel 的 map() 方法 将文件区域直接映射到内存中来创建 。该方法返回MappedByteBuffe
*/
public class TestBuffer {
@Test
public void test1(){
String str="abcde";
//1.分配一个指定大小的缓冲区
ByteBuffer buf=ByteBuffer.allocate(1024);
System.out.println("--------------allocate()----------------");
System.out.println(buf.position());//0
System.out.println(buf.limit());//1024
System.out.println(buf.capacity());//1024
//2.利用put()存放数据到缓冲区中
buf.put(str.getBytes());
System.out.println("-------------put()-------------");
System.out.println(buf.position());//5
System.out.println(buf.limit());//1024
System.out.println(buf.capacity());//1024
//3.切换读取数据模式
buf.flip();
System.out.println("--------------flip()------------");
System.out.println(buf.position());//0
System.out.println(buf.limit());//5
System.out.println(buf.capacity());//1024
//4.利用get()读取缓冲区中的数据
byte[] dst=new byte[buf.limit()];
buf.get(dst);
System.out.println(new String(dst,0,dst.length));//abcd
System.out.println("--------------get()------------");
System.out.println(buf.position());//5
System.out.println(buf.limit());//5
System.out.println(buf.capacity());//1024
//5.rewind():可重复读
buf.rewind();
System.out.println("--------------rewind()------------");
System.out.println(buf.position());//0
System.out.println(buf.limit());//5
System.out.println(buf.capacity());//1024
//6.clear():清空缓冲区。但是缓冲区中的数据依然存在，但是处在“被遗忘”状态
buf.clear();
System.out.println("--------------clear()------------");
System.out.println(buf.position());//0
System.out.println(buf.limit());//1024
System.out.println(buf.capacity());//1024
System.out.println((char)buf.get());
}
@Test
public void test2(){
String str="abcde";
ByteBuffer buf=ByteBuffer.allocate(1024);
buf.put(str.getBytes());
buf.flip();
byte[] dst=new byte[buf.limit()];
buf.get(dst,0,2);
System.out.println(new String(dst,0,2));//ab
System.out.println(buf.position());//2
//mark():标记
buf.mark();
buf.get(dst,2,2);//再读两个位置
System.out.println(new String(dst, 2, 2));//cd
System.out.println(buf.position());//4
//reset():恢复到mark的位置
buf.reset();
System.out.println(buf.position());//2
//判断缓冲区中是否还有剩余数据
if(buf.hasRemaining()){
//获取缓冲区中可以操作的数量
System.out.println(buf.remaining());//3
}
}
@Test
public void test3(){
//分配直接缓冲区
ByteBuffer buf=ByteBuffer.allocate(1024);
System.out.println(buf.isDirect());//false
}
}
2、通道（Channel）
通道：由java.nio.channels包定义。
Channel表示IO源与目标打开的连接。
Channel类似于传统的“流”。但其自身不能直接访问数据，Channel只能与Buffer进行交互。
操作系统中：通道是一种通过执行通道程序管理I/O操作的控制器，它使主机（CPU和内存）与I/O操作之间达到更高的并行程度。需要进行I/O操作时，CPU只需启动通道，然后可以继续执行自身程序，通道则执行通道程序，管理与实现I/O操作。
FileChannel 的常用方法
/*
* 一、通道(Channel):用于源节点与目标节点的连接。在java NIO中负责缓冲区中数据的传输。Channel本身不存储数据，需要配合缓冲区进行传输。
*
* 二、通道的主要实现类
* java.nio.channels.Channel 接口：
* |--FileChannel：用于读取、写入、映射和操作文件的通道。
* |--SocketChannel：通过 TCP 读写网络中的数据。
* |--ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
* |--DatagramChannel：通过 UDP 读写网络中的数据通道。
*
* 三、获取通道
* 1.java针对支持通道的类提供了getChannel()方法
* 本地IO：
* FileInputStream/FileOutputStream
* RandomAccessFile
*
* 网络IO：
* Socket
* ServerSocket
* DatagramSocket
*
* 2.在JDK 1.7 中的NIO.2 针对各个通道提供了静态方法 open()
* 3.在JDK 1.7 中的NIO.2 的Files工具类的newByteChannel()
*
* 四、通道之间的数据传输
* transferFrom()
* transferTo()
*
* 五、分散(Scatter)与聚集(Gather)
* 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
* 聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中
*
* 六、字符集：Charset
* 编码：字符串-》字符数组
* 解码：字符数组-》字符串
*/
public class TestChannel {
//利用通道完成文件的复制(非直接缓冲区)
@Test
public void test1(){
long start=System.currentTimeMillis();
FileInputStream fis=null;
FileOutputStream fos=null;
FileChannel inChannel=null;
FileChannel outChannel=null;
try{
fis=new FileInputStream("d:/1.avi");
fos=new FileOutputStream("d:/2.avi");
//1.获取通道
inChannel=fis.getChannel();
outChannel=fos.getChannel();
//2.分配指定大小的缓冲区
ByteBuffer buf=ByteBuffer.allocate(1024);
//3.将通道中的数据存入缓冲区中
while(inChannel.read(buf)!=-1){
buf.flip();//切换读取数据的模式
//4.将缓冲区中的数据写入通道中
outChannel.write(buf);
buf.clear();//清空缓冲区
}
}catch(IOException e){
e.printStackTrace();
}finally{
if(outChannel!=null){
try {
outChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(inChannel!=null){
try {
inChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long end=System.currentTimeMillis();
System.out.println("耗费时间："+(end-start));//耗费时间：1094
}
//使用直接缓冲区完成文件的复制(内存映射文件)
@Test
public void test2() {
long start=System.currentTimeMillis();
FileChannel inChannel=null;
FileChannel outChannel=null;
try {
inChannel = FileChannel.open(Paths.get("d:/1.avi"), StandardOpenOption.READ);
outChannel=FileChannel.open(Paths.get("d:/2.avi"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
//内存映射文件
MappedByteBuffer inMappedBuf=inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
MappedByteBuffer outMappedBuf=outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
//直接对缓冲区进行数据的读写操作
byte[] dst=new byte[inMappedBuf.limit()];
inMappedBuf.get(dst);
outMappedBuf.put(dst);
} catch (IOException e) {
e.printStackTrace();
}finally{
if(outChannel!=null){
try {
outChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(inChannel!=null){
try {
inChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long end=System.currentTimeMillis();
System.out.println("耗费的时间为："+(end-start));//耗费的时间为：200
}
//通道之间的数据传输(直接缓冲区)
@Test
public void test3(){
long start=System.currentTimeMillis();
FileChannel inChannel=null;
FileChannel outChannel=null;
try {
inChannel = FileChannel.open(Paths.get("d:/1.avi"), StandardOpenOption.READ);
outChannel=FileChannel.open(Paths.get("d:/2.avi"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
inChannel.transferTo(0, inChannel.size(), outChannel);
outChannel.transferFrom(inChannel, 0, inChannel.size());
} catch (IOException e) {
e.printStackTrace();
}finally{
if(outChannel!=null){
try {
outChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(inChannel!=null){
try {
inChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long end=System.currentTimeMillis();
System.out.println("耗费的时间为："+(end-start));//耗费的时间为：147
}
//分散和聚集
@Test
public void test4(){
RandomAccessFile raf1=null;
FileChannel channel1=null;
RandomAccessFile raf2=null;
FileChannel channel2=null;
try {
raf1=new RandomAccessFile("1.txt","rw");
//1.获取通道
channel1=raf1.getChannel();
//2.分配指定大小的缓冲区
ByteBuffer buf1=ByteBuffer.allocate(100);
ByteBuffer buf2=ByteBuffer.allocate(1024);
//3.分散读取
ByteBuffer[] bufs={buf1,buf2};
channel1.read(bufs);
for(ByteBuffer byteBuffer : bufs){
byteBuffer.flip();
}
System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
System.out.println("--------------------");
System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
//4.聚集写入
raf2=new RandomAccessFile("2.txt", "rw");
channel2=raf2.getChannel();
channel2.write(bufs);
}catch (IOException e) {
e.printStackTrace();
}finally{
if(channel2!=null){
try {
channel2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(channel1!=null){
try {
channel1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(raf2!=null){
try {
raf2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(raf1!=null){
try {
raf1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//输出支持的字符集
@Test
public void test5(){
Map<String,Charset> map=Charset.availableCharsets();
Set<Entry<String,Charset>> set=map.entrySet();
for(Entry<String,Charset> entry:set){
System.out.println(entry.getKey()+"="+entry.getValue());
}
}
//字符集
@Test
public void test6(){
Charset cs1=Charset.forName("GBK");
//获取编码器
CharsetEncoder ce=cs1.newEncoder();
//获取解码器
CharsetDecoder cd=cs1.newDecoder();
CharBuffer cBuf=CharBuffer.allocate(1024);
cBuf.put("啦啦哈哈吧吧");
cBuf.flip();
//编码
ByteBuffer bBuf=null;
try {
bBuf = ce.encode(cBuf);
} catch (CharacterCodingException e) {
e.printStackTrace();
}
for(int i=0;i<12;i++){
System.out.println(bBuf.get());//-64-78-64-78-71-2-7-2-80-55-80-55
}
//解码
bBuf.flip();
CharBuffer cBuf2=null;
try {
cBuf2 = cd.decode(bBuf);
} catch (CharacterCodingException e) {
e.printStackTrace();
}
System.out.println(cBuf2.toString());//啦啦哈哈吧吧
}
}