第十二章 NIO

12、NIO
12.1 Java NIO 概述	1课时
12.2 Java NIO.2 之Path、Paths 与 Files 的使用	1课时
12.3 自动资源管理	1课时
12.4 缓冲区(Buffer)	1课时
12.5 通道(Channel)与文件通道(FileChannel)	1课时
12.6管道(Pipe)中的SinkChannel和SourceChannel	1课时
12.7 字符集(Charset)	1课时

##12-1 Java NIO 概述

Java NIO 概述

Java NIO (New IO，Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。

NIO. 2

随着 JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为 NIO.2。因为 NIO 提供的一些功能，NIO已经成为文件处理中越来越重要的部分。

Java NIO 与 IO 的主要区别

<tr>
	<td >IO</td>    
    <td >NIO</td>  
</tr>
<tr>
	<td >面向流(Stream Oriented)：单向的</td>    
    <td >面向缓冲区(Buffer Oriented)：通道是单向的，也可以是双向的</td>  
</tr>
<tr>
	<td >阻塞IO(Blocking IO)</td>    
    <td >非阻塞IO(Non Blocking IO)</td>  
</tr>
<tr>
	<td >(无)</td>    
    <td >选择器(Selectors)</td>  
</tr>

##12-2 NIO.2 之 Path、Paths、Files的使用

Path接口

Path 常用方法：
- String toString() ：返回调用 Path 对象的字符串表示形式
- boolean startsWith(String path) : 判断是否以 path 路径开始
- boolean endsWith(String path) : 判断是否以 path 路径结束
- boolean isAbsolute() : 判断是否是绝对路径
- Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
- Path getRoot() ：返回调用 Path 对象的根路径
- Path getFileName() : 返回与调用 Path 对象关联的文件名
- Path getName(int idx) : 返回指定索引位置 idx 的路径名称
- int getNameCount() : 返回Path 根目录后面元素的数量
- Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
- Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
- File toFile(): 将Path转化为File类的对象
java.nio.file.Files 用于操作文件或目录的工具类。
Files常用方法：
- Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
- Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
- Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
- void delete(Path path) : 删除一个文件，如果不存在，执行报错
- void deleteIfExists(Path path) : Path对应的文件如果存在，执行删除
- Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
- long size(Path path) : 返回 path 指定文件的大小
Files常用方法：用于判断
- boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
- boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
- boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
- boolean isHidden(Path path) : 判断是否是隐藏文件
- boolean isReadable(Path path) : 判断文件是否可读
- boolean isWritable(Path path) : 判断文件是否可写
- boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
Files常用方法：用于操作内容
- SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。
- DirectoryStream newDirectoryStream(Path path) : 打开 path 指定的目录
- InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
- OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象

Path案例

/**
 * 1. jdk 7.0 时，引入了 Path、Paths、Files三个类。
 * 2.此三个类声明在：java.nio.file包下。
 * 3.Path可以看做是java.io.File类的升级版本。也可以表示文件或文件目录，与平台无关
 * 
 * 4.如何实例化Path:使用Paths.
 * 	 static Path get(String first, String … more) : 用于将多个字符串串连成路径
 *   static Path get(URI uri): 返回指定uri对应的Path路径
 */
public class PathTest {
	
	//Path中的常用方法
	@Test
	public void test2(){
		Path path1 = Paths.get("d:\", "nio\nio1\nio2\hello.txt");
		Path path2 = Paths.get("hello.txt");
		
//		String toString() ： 返回调用 Path 对象的字符串表示形式
		System.out.println(path1);
		
//		boolean startsWith(String path) : 判断是否以 path 路径开始
		System.out.println(path1.startsWith("d:\nio"));
//		boolean endsWith(String path) : 判断是否以 path 路径结束
		System.out.println(path1.endsWith("hello.txt"));
//		boolean isAbsolute() : 判断是否是绝对路径
		System.out.println(path1.isAbsolute() + "~");
		System.out.println(path2.isAbsolute() + "~");
//		Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
		System.out.println(path1.getParent());
		System.out.println(path2.getParent());
//		Path getRoot() ：返回调用 Path 对象的根路径
		System.out.println(path1.getRoot());
		System.out.println(path2.getRoot());
//		Path getFileName() : 返回与调用 Path 对象关联的文件名
		System.out.println(path1.getFileName() + "~");
		System.out.println(path2.getFileName() + "~");
//		int getNameCount() : 返回Path 根目录后面元素的数量
//		Path getName(int idx) : 返回指定索引位置 idx 的路径名称
		for(int i = 0;i < path1.getNameCount();i++){
			System.out.println(path1.getName(i) + "*****");
		}
		
//		Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
		System.out.println(path1.toAbsolutePath());
		System.out.println(path2.toAbsolutePath());
//		Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
		Path path3 = Paths.get("d:\", "nio");
		Path path4 = Paths.get("nioo\hi.txt");
		path3 = path3.resolve(path4);
		System.out.println(path3);
		
//		File toFile(): 将Path转化为File类的对象
		File file = path1.toFile();//Path--->File的转换
		
		Path newPath = file.toPath();//File--->Path的转换
		
	}
	
	//如何使用Paths实例化Path
	@Test
	public void test1(){
		Path path1 = Paths.get("d:\nio\hello.txt");//new File(String filepath)
		
		Path path2 = Paths.get("d:\", "nio\hello.txt");//new File(String parent,String filename);
		
		System.out.println(path1);
		System.out.println(path2);
		
		Path path3 = Paths.get("d:\", "nio");
		System.out.println(path3);
	}
}

Files案例

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.Iterator;

import org.junit.Test;
/**
 * Files工具类的使用：操作文件或目录的工具类
 *
 */
public class FilesTest {
	
	
	/**
	 * StandardOpenOption.READ:表示对应的Channel是可读的。
	 * StandardOpenOption.WRITE：表示对应的Channel是可写的。
	 * StandardOpenOption.CREATE：如果要写出的文件不存在，则创建。如果存在，忽略
	 * StandardOpenOption.CREATE_NEW：如果要写出的文件不存在，则创建。如果存在，抛异常
	 */
	@Test
	public void test3() throws IOException{
//		SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。
		Path path1 = Paths.get("d:\nio", "hello.txt");
		SeekableByteChannel channel = Files.newByteChannel(path1, StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);
		
//		DirectoryStream<Path>  newDirectoryStream(Path path) : 打开 path 指定的目录
		Path path2 = Paths.get("e:\teach");
		DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path2);
		Iterator<Path> iterator = directoryStream.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		
//		InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
		InputStream inputStream = Files.newInputStream(path1, StandardOpenOption.READ);
		
//		OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象
		OutputStream outputStream = Files.newOutputStream(path1, StandardOpenOption.WRITE,StandardOpenOption.CREATE);
		
	}
	
	@Test
	public void test2() throws IOException{
		Path path1 = Paths.get("d:\nio", "hello.txt");
		Path path2 = Paths.get("xxx.txt");
//		boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
		System.out.println(Files.exists(path2, LinkOption.NOFOLLOW_LINKS));
		
//		boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
		//不要求此path对应的物理文件存在。
		System.out.println(Files.isDirectory(path1, LinkOption.NOFOLLOW_LINKS));
		
//		boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
		
//		boolean isHidden(Path path) : 判断是否是隐藏文件
		//要求此path对应的物理上的文件需要存在。才可判断是否隐藏。否则，抛异常。
//		System.out.println(Files.isHidden(path1));
		
//		boolean isReadable(Path path) : 判断文件是否可读
		System.out.println(Files.isReadable(path1));
//		boolean isWritable(Path path) : 判断文件是否可写
		System.out.println(Files.isWritable(path1));
//		boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
		System.out.println(Files.notExists(path1, LinkOption.NOFOLLOW_LINKS));
	}
	
	@Test
	public void test1() throws IOException{
		Path path1 = Paths.get("d:\nio", "hello.txt");
		Path path2 = Paths.get("xxx.txt");
		
//		Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
		//要想复制成功，要求path1对应的物理上的文件存在。path1对应的文件没有要求。
//		Files.copy(path1, path2, StandardCopyOption.REPLACE_EXISTING);
		
//		Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
		//要想执行成功，要求path对应的物理上的文件目录不存在。一旦存在，抛出异常。
		Path path3 = Paths.get("d:\nio\nio1");
//		Files.createDirectory(path3);
		
//		Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
		//要想执行成功，要求path对应的物理上的文件不存在。一旦存在，抛出异常。
		Path path4 = Paths.get("d:\nio\hi.txt");
//		Files.createFile(path4);
		
//		void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错
//		Files.delete(path4);
		
//		void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除.如果不存在，正常执行结束
		Files.deleteIfExists(path3);
		
//		Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
		//要想执行成功，src对应的物理上的文件需要存在，dest对应的文件没有要求。
//		Files.move(path1, path2, StandardCopyOption.ATOMIC_MOVE);
		
//		long size(Path path) : 返回 path 指定文件的大小
		long size = Files.size(path2);
		System.out.println(size);

	}
}

Path、Paths和Files核心API

早期的java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。

NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。

在以前IO操作都是这样写的:

import java.io.File;
File file = new File("index.html");

但在Java7 中，我们可以这样写：

import java.nio.file.Path; 
import java.nio.file.Paths; 
Path path = Paths.get("index.html");

同时，NIO.2还提供了Files、Paths工具类，Files包含了大量静态的工具方法来操作文件；Paths则包含了两个返回Path的静态工厂方法。

Paths 类提供的静态 get() 方法用来获取 Path 对象：

  static Path get(String first, String … more) : 用于将多个字符串串连成路径
  static Path get(URI uri): 返回指定uri对应的Path路径

URI、URL和URN的区别

URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。而URL是uniform resource locator，统一资源定位符，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。而URN，uniform resource name，统一资源命名，是通过名字来标识资源，比如mailto:java-net@java.sun.com。也就是说，URI是以一种抽象的，高层次概念定义统一资源标识，而URL和URN则是具体的资源标识的方式。URL和URN都是一种URI。

在Java的URI中，一个URI实例可以代表绝对的，也可以是相对的，只要它符合URI的语法规则。而URL类则
不仅符合语义，还包含了定位该资源的信息，
因此它不能是相对的。

12-3 自动资源管理

自动资源管理案例

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;

/**
 * 
 * jdk 7 提供基于try-catch的自动资源管理

 */
public class ARMTest {
	
	/**
	 * 能够实现资源的自动关闭，需要满足：
	 * 1.可以在一条 try 语句中管理多个资源，每个资源以“;” 隔开即可。
	 * 2.需要关闭的资源，必须实现了 AutoCloseable 接口或其子接口 Closeable
	 * 
	 * 目的：不需要再使用finally，显式的关闭资源了。
	 * 
	 */
	@Test
	public void test2(){
		try(
				FileInputStream fis = new FileInputStream("xxx.txt");
				FileOutputStream fos = new FileOutputStream("abc.txt");
				SeekableByteChannel channel = Files.newByteChannel(Paths.get("d:\nio", "hello.txt"), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE)
			)
		{
			//可能出现异常的代码
			int data;
			while((data = fis.read()) != -1){
				System.out.println((char)data);
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	@Test
	public void test1() {
		
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("xxx.txt");
			int data;
			while((data = fis.read()) != -1){
				System.out.println((char)data);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				
			}
		}
		
		
		
	}
}

Java 7 增加了一个新特性，该特性提供了另外一种管理资源的方式，这种方式能自动关闭文件。这个特性有时被称为自动资源管理(Automatic Resource Management, ARM)，该特性以 try 语句的扩展版为基础。自动资源管理主要用于当不再需要文件（或其他资源）时，可以防止无意中忘记释放它们。

自动资源管理基于 try 语句的扩展形式：

  try(需要关闭的资源声明){
  	//可能发生异常的语句
  }catch(异常类型 变量名){
  	//异常的处理语句
  }
  ……
  finally{
  	//一定执行的语句
  }

当 try 代码块结束时，自动释放资源。因此不需要显示的调用 close() 方法。该形式也称为“带资源的 try 语句”。

注意：

① try 语句中声明的资源被隐式声明为 final ，资源的作用局限于带资源的 try 语句

② 可以在一条 try 语句中管理多个资源，每个资源以“;” 隔开即可。

③ 需要关闭的资源，必须实现了 AutoCloseable 接口或其子接口 Closeable

FileUtils案例

导入import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;

import org.apache.commons.io.FileUtils;
import org.junit.Test;

public class FileUtilsTest {
	
	@Test
	public void test1() throws IOException{
		File srcFile = new File("Dilraba.jpg");
		File destFile = new File("Dilraba1.jpg");
		FileUtils.copyFile(srcFile, destFile);
	}
}

12-4 缓冲区(Buffer)

缓冲区案例

import java.nio.ByteBuffer;
import java.nio.CharBuffer;

import org.junit.Test;


/**
 * 一、NIO的使用中两个重要的要素：缓冲区(Buffer)、通道(Channel)
 * 缓冲区(Buffer):存储数据的。   ---->byte[] buffer = new byte[1024]
 * 通道(Channel)：代表着数据源与目标节点之间的连接，负责缓冲区的传输。 --->IO流
 * 
 * 二者的交互：Java NIO 中的 Buffer 主要用于与 NIO 通道(Channel)进行交互，
 * 数据是从通道读入缓冲区，从缓冲区写入通道中的。

 * 
 * 二、缓冲区（Buffer）的结构 (除boolean之外)
 *   java.nio.Buffer抽象类
 *   	|----ByteBuffer
 *   	|----CharBuffer
 *   
 *   	|----ShortBuffer
 *   	|----IntBuffer
 *   	|----LongBuffer
 *   	|----FloatBuffer
 *   	|----DoubleBuffer
 *   XxxBuffer底层使用xxx[]进行存储。
 * 
 * 三、如何实例化缓冲区？调用缓冲区类XxxBuffer的静态方法：allocate(int capacity)
 *   举例：ByteBuffer byteBuffer = ByteBuffer.allocate(10);byte[] hb = new byte[10];
 *   	类似：ArrayList list = new ArrayList(10);//Object[] eleData = new Object[10];
 *   说明：方法的形参，决定了底层创建的数组的长度
 * 
 * 四、Buffer中的常用属性：
 * 	  capacity:容量，决定了底层数组的长度，表明了最大存储数据的容量
 *    limit:限制，默认情况下，limit等于capacity.在读数据模式下，limit<=capacity.表明最大可以读取数据的量
 *    position:位置，表明了当前读取或写入数据的位置
 *    mark:标记。默认值为-1.
 *    
 *    关系式：mark <= position <= limit <= capacity
 *    
 *    类比：项目三中TeamService类中的属性：
 *    private final int MAX_MEMBER = 5;//相当于capacity
	  private Programmer[] team = new Programmer[MAX_MEMBER];//Buffer底层封装的数组
	  private int total;//相当于limit
 *    index:读取、写入数组指定为的索引：position
 *    
 * 五、Buffer中的常用方法：
 *      1）最基本的两个方法：put(Xxx xxx) / get()
 *      2）其他方法：见ppt中的表格即可。
 * 
 * 六、针对于ByteBuffer来讲，可以创建非直接缓冲区：allocate(int capacity)
 * 							   直接缓冲区：allocateDirect(int capacity) / FileChannel 的 map()
 *    
 *    了解非直接缓冲区 与 直接缓冲区的区别
 */
public class BufferTest {
	
	@Test
	public void test3(){
		ByteBuffer byteBuffer = ByteBuffer.allocate(10);
		byteBuffer.put("hello".getBytes());
		
		//array():返回缓冲区底层的数组
		byte[] array = byteBuffer.array();
		System.out.println(array.length);
		
		for(int i = 0;i < array.length;i++){
			System.out.println(array[i]);
		}
		
		//isDirect():判断此时的字节缓冲区是否是直接缓冲区
		System.out.println(byteBuffer.isDirect());
	}
	
	@Test
	public void test2(){
		ByteBuffer byteBuffer = ByteBuffer.allocate(10);
		byteBuffer.put("hello".getBytes());
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		byteBuffer.flip();
		byte[] dst = new byte[5];	
		byteBuffer.get(dst,0,2);//从数组角标0开始，写入两个字节的数组
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		System.out.println("***********mark()***************");
		byteBuffer.mark();//标记当前position的位置
		
		byteBuffer.get(dst,2,2);//从数组角标2开始，写入两个字节的数组
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
//		byteBuffer.rewind();//position = 0;
		//reset():此方法必须要配合着mark()使用。调用此方法其调用mark(),否则抛异常。
		byteBuffer.reset();//position = mark;即为将position置为标记的位置
		
		
		if(byteBuffer.hasRemaining()){//判断是否还有元素没有读取到。
			System.out.println(byteBuffer.remaining());//还有几个没有读取到。
		}
		System.out.println();
		
		while(byteBuffer.hasRemaining()){
			System.out.println((char)byteBuffer.get());
		}
		
		
		
	}
	
	
	@Test
	public void test1(){
		System.out.println("*********allocate(10)************");
		ByteBuffer byteBuffer = ByteBuffer.allocate(10);
//		CharBuffer charBuffer = CharBuffer.allocate(10);
		
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		System.out.println("*********put()************");
		byteBuffer.put("hello".getBytes());//写入长度为5的字节数.每put一个字节，position就+1
		
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		System.out.println("*********flip()************");
		byteBuffer.flip();//切换为读数据模式。将limit设置为position，position归零
		
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		System.out.println("*********get()************");
		//方式一：
//		System.out.println((char)byteBuffer.get());//每get一个字节，position也自动+1
//		System.out.println((char)byteBuffer.get());
		
		//方式二：
		byte[] dst = new byte[3];
		byteBuffer.get(dst);
		
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		
//		System.out.println("*********rewind()************");
//		byteBuffer.rewind();//重置position
//		System.out.println(byteBuffer.capacity());
//		System.out.println(byteBuffer.limit());
//		System.out.println(byteBuffer.position());
		
		
		System.out.println("*********clear()************");
		byteBuffer.clear();//清空.将position归零，limit设置为capacity.数据并未删除。
		System.out.println(byteBuffer.capacity());
		System.out.println(byteBuffer.limit());
		System.out.println(byteBuffer.position());
		
		System.out.println((char)byteBuffer.get());
	}
}

缓冲区和通道

Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示IO源到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。

简而言之，Channel 负责传输， Buffer 负责存储数据

缓冲区 (Buffer)

缓冲区(Buffer)：一个用于特定基本数据类型(除boolean型外)的容器，底层使用数组存储。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。
Java NIO 中的 Buffer 主要用于与 NIO 通道(Channel)进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。

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

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

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

缓冲区的基本属性

容量 (capacity) ：表示 Buffer 最大数据容量，一旦声明后，不能更改。通过Buffer中的capacity()获取。缓冲区capacity不能为负。
限制 (limit)：第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。通过Buffer中的limit()获取。缓冲区的limit不能为负，并且不能大于其capacity。
位置 (position)：当前要读取或写入数据的索引。通过Buffer中的position()获取。缓冲区的position不能为负，并且不能大于其limit。
标记 (mark)：标记是一个索引，通过 Buffer 中的 mark() 方法将mark标记为当前position位置。之后可以通过调用 reset() 方法将 position恢复到标记的mark处。
标记、位置、限制、容量遵守以下不变式：
0 <= mark <= position <= limit <= capacity

缓冲区的数据基本操作

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

put(Xxx xxx) 与 get() 方法

以ByteBuffer类为例：

放入数据到 Buffer 中

put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)
获取 Buffer 中的数据

get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)

12-5 通道(Channel)与文件通道(FileChannel)

通道案例

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;

/**
 * 一、java.nio.channels.Channel接口
 *   Channel:不负责存储数据，数据存储在Buffer中，Channel负责Buffer的传输
 *   
 * 
 * 二、
 * java.nio.channels.Channel
 * 		|-----FileChannel:处理本地文件
 * 		
 * 		|-----SocketChannel：TCP网络编程的客户端的Channel
 * 		|-----ServerSocketChannel:TCP网络编程的服务器端的Channel
 * 		|-----DatagramChannel：UDP网络编程中发送端和接收端的Channel
 * 
 * 		|-----Pipe.SinkChannel
 * 		|-----Pipe.SourceChannel
 * 
 * 三、如何实例化Channel
 * 		方式一：调用相关结构的getChannel()
 * 		FileInputStream / FileOutputStream / RandomAccessFile ----> FileChannel
 * 		
 * 		Socket --->SocketChannel
 * 		ServerSocket ---->ServerSocketChannel
 * 		DatagramSocket --->DatagramChannel
 * 
 * 		说明：Channel可以是单向的，也可以是双向的。
 * 		
 *     方式二：XxxChannel的静态方法：open().  
 *     方式三：Files工具类的静态方法：newByteChannel() 得到的是字节通道。
 * 	       说明：方式二和方式三在jdk7.0新增的。
 * 
 * 四、Channel的常用方法：读：read(ByteBuffer buffer) / write(ByteBuffer buffer)
 */
public class ChannelTest {
	
	
	@Test
	public void test4() throws Exception{
		
		RandomAccessFile readRaf = new RandomAccessFile("IDEA.java", "r");
		RandomAccessFile writeRaf = new RandomAccessFile("NEWIDEA.java", "rw");
		
		//实例化Channel
		FileChannel inChannel = readRaf.getChannel();
		FileChannel outChannel = writeRaf.getChannel();
		
		ByteBuffer buffer1 = ByteBuffer.allocate(1024);
		ByteBuffer buffer2 = ByteBuffer.allocate(2048);
		ByteBuffer[] dsts = {buffer1,buffer2};
		
		inChannel.read(dsts);//分散读取
		
		//改为可读模式
		buffer1.flip();
		buffer2.flip();
		System.out.println(new String(buffer1.array(),0,buffer1.limit()));
		System.out.println();
		System.out.println(new String(buffer2.array(),0,buffer2.limit()));
		
		//测试聚集写入
		outChannel.write(dsts);
		
		
		outChannel.close();
		inChannel.close();
	}
	
	@Test
	public void test3() throws IOException{
		FileChannel inChannel = FileChannel.open(Paths.get("Dilraba.jpg"), StandardOpenOption.READ);
		
		FileChannel outChannel = FileChannel.open(Paths.get("mm1.jpg"), StandardOpenOption.WRITE,StandardOpenOption.CREATE);
		
		//transferTo():将数据从可读的Channel中转换到可写的Channel中
//		inChannel.transferTo(0, inChannel.size(), outChannel);
		//transferFrom():将数据从可读的Channel中转换到可写的Channel中
		outChannel.transferFrom(inChannel, 0, inChannel.size());
		
		
		inChannel.close();
		outChannel.close();
		
	}
	
	//使用Channel实例化的方式二，使用直接缓冲区，实现文件的复制
	@Test
	public void test2(){
		FileChannel inChannel = null;
		FileChannel outChannel = null;
		try {
			long start = System.currentTimeMillis();
			
//			String srcPath = "Dilraba.jpg";
//			String destPath = "Dilraba3.jpg";
			
			
			String srcPath = "C:\Users\Administrator\Desktop\score\战狼.mp4";
			String destPath = "C:\Users\Administrator\Desktop\score\战狼1.mp4";
			
			
			//实例化Channel
			inChannel = FileChannel.open(Paths.get(srcPath), StandardOpenOption.READ);
			outChannel = FileChannel.open(Paths.get(destPath), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);
			
			//得到直接缓冲区
			MappedByteBuffer inMappedBuffer = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());//size():返回操作的文件的大小
			MappedByteBuffer outMappedBuffer = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
			
			//数据的读写操作
			byte[] buffer = new byte[inMappedBuffer.limit()];
			inMappedBuffer.get(buffer);
			outMappedBuffer.put(buffer);
			
			
			long end = System.currentTimeMillis();
			System.out.println("直接缓冲区花费的时间：" + (end - start));//1929-1894
			
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(inChannel != null){
				try {
					inChannel.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				
			}
			if(outChannel != null){
				
				try {
					outChannel.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		
	}
	
	
	//使用Channel实例化的方式一，使用非直接缓冲区，实现文件的复制操作
	@Test
	public void test1(){
		FileChannel inChannel = null;
		FileChannel outChannel = null;
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			
			long start = System.currentTimeMillis();
			
//			String srcPath = "Dilraba.jpg";
//			String destPath = "Dilraba2.jpg";
			
			
			String srcPath = "C:\Users\Administrator\Desktop\score\战狼.mp4";
			String destPath = "C:\Users\Administrator\Desktop\score\战狼2.mp4";
			
			
			fis = new FileInputStream(srcPath);
			fos = new FileOutputStream(destPath);
			
			//实例化Channel
			inChannel = fis.getChannel();
			outChannel = fos.getChannel();
			
			//提供ByteBuffer
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			while(inChannel.read(buffer) != -1){
				buffer.flip();//修改为读数据模式
				outChannel.write(buffer);
				buffer.clear();//清空
			}
			
			long end = System.currentTimeMillis();
			System.out.println("非直接缓冲区花费的时间：" + (end - start));//20795-13768
			
		} catch (Exception 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();
				}
				
			}
			
		}
		
		
	}
}

通道 (Channel)

通道 (Channel)：由 java.nio.channels 包定义的。
- Channel 表示 IO 源与目标节点打开的连接。
- Channel 类似于传统的“流”。只不过 Channel 本身不能直接存储数据，Channel 只能与 Buffer 进行交互。

传统的IO和NIO理解

PIO（parts in one）模式下硬盘和内存之间的数据传输是由CPU来控制的

DMA模式下，CPU必须向DMA（理解为秘书）控制器下达命令，让DMA控制器来处理数据的传送，数据传输玩波比再把信息反馈给CPU，这样就很大程度上减轻了CPU资源占有率，可以大大节省系统资源。
DMA模式又可以分为Single-Word(单字节DMA)和Multi-Word(多字节DMA)两种，其中所能达到的最大传输速率也只能有16.6MB/s.

12-6 管道(Pipe)中的SinkChannel和SourceChannel

管道(Pipe)案例

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

import org.junit.Test;

public class PipeTest {

	/**
	 * 管道的中SinkChannel 和 SourceChannel使用举例
	 * @throws IOException
	 */
	@Test
	public void test1() throws IOException{
		//获取管道
		Pipe pipe = Pipe.open();
		
		//将缓冲区中的数据写入管道
		ByteBuffer buf = ByteBuffer.allocate(1024);
		//线程1
		Pipe.SinkChannel sinkChannel = pipe.sink();
		buf.put("通过单向管道发送数据".getBytes());
		buf.flip();
		sinkChannel.write(buf);
		
		//线程2
		//读取缓冲区中的数据
		Pipe.SourceChannel sourceChannel = pipe.source();
		buf.flip();
		int len = sourceChannel.read(buf);
		System.out.println(new String(buf.array(), 0, len));
		
		sourceChannel.close();
		sinkChannel.close();
	}
	
}

12-7 字符集(Charset)

字符集案例

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;

import org.junit.Test;

/**
 * Charset:字符集
 * 
 * 1.如何实例化：Charset的静态方法：forName(String charset)
 * 
 * 2.如何得到编码器和解码器：newEncoder()/newDecoder();
 */
public class CharsetTest {
	
	
	@Test
	public void test2() throws Exception{
		//1.如何实例化
//		Charset charset = Charset.forName("gbk");
		Charset charset = Charset.forName("utf-8");
		
		//2.得到编码器 和 解码器
		CharsetEncoder encoder = charset.newEncoder();//编码器
		CharsetDecoder decoder = charset.newDecoder();//解码器
		
		CharBuffer charBuffer = CharBuffer.allocate(1024);
		charBuffer.put("保持微笑");
		charBuffer.flip();
		ByteBuffer byteBuffer = encoder.encode(charBuffer);//编码
		//将编码后的数据输出到控制台
//		byte[] array = byteBuffer.array();
		for(int i = 0;i < byteBuffer.limit();i++){
//			System.out.println(array[i]);
			System.out.println(byteBuffer.get());
		}
		
		byteBuffer.flip();
		CharBuffer charBuffer2 = decoder.decode(byteBuffer);//解码
		
		System.out.println(new String(charBuffer2.array(),0,charBuffer2.limit()));
		
		System.out.println("******************");
		Charset charset1 = Charset.forName("gbk");
		CharsetDecoder decoder2 = charset1.newDecoder();
		byteBuffer.flip();
		CharBuffer charBuffer3 = decoder2.decode(byteBuffer);//解码
		
		System.out.println(new String(charBuffer3.array(),0,charBuffer3.limit()));
		
		
	}
	
	
	@Test
	public void test1(){
		SortedMap<String,Charset> charsets = Charset.availableCharsets();
		Set<Entry<String,Charset>> entrySet = charsets.entrySet();
		
		Iterator<Entry<String, Charset>> iterator = entrySet.iterator();
		while(iterator.hasNext()){
			Entry<String, Charset> entry = iterator.next();
			System.out.println(entry.getKey() + "---->" + entry.getValue());
		}
		
	}
}