java 新 IO（6）
问题：如果一个程序现在需要等待用户输入数据，则可以通过 system.in 来完成。但是这样一来，在使用时就会出现一个问题：
如果用户没有输入信息，则肯定会一直等待用户输入，大量的系统资源就会被败白白浪费。所以在 jdk 1.4 之后引入了 新IO 处理机制。---NIO .
IO的阻塞操作：
我们知道 在IO操作中从键盘解说数据是我们会使用readLine（）方法，程序就要停止等待用户输入数据；在网络编程中我们知道在服务器端使用ServletSocket 类的accept（） 方法时，服务器会一直处于等待操作，等待客户端连接。这两类操作都属于阻塞操作，因为都会让程序暂停。
新IO并没有在原来的IO基础上开发，而是采用了全新的类和接口，除了原有的功能之外还提供了一下新的特性：
多路选择的非封锁式I/O设施；
支持文件锁和内存映射；
支持正则表达式的模式匹配设施；
字符集编码器和译码器。
在新IO中使用 Buffer 和Channel 支持以上的操作。
一、缓冲区与Buffer
1、基本操作：
在基本IO操作中所有的操作都是直接一流的形式完成的；而在NIO中所有的操作都要使用缓冲区处理，且所有的读写操作都是通过缓冲区完成的。缓冲区（Buffer）是一个线性的、有序的数据集，只能容纳某种特定的事数据类型。
java.nio.Buffer 本身是一个抽象类；
Buffer有四个基本属性：
1、capacity 容量，buffer能够容纳的最大元素数目，在Buffer创建时设定并不能更改
2、limit buffer中有效位置数目
3、position 下一个读或者写的位置
4、mark 用于记忆的标志位，配合reset()使用，初始值未设定，调用mark后将当前position设为值
四者关系：0 <= mark <= position <= limit <= capacity
API:
package java.nio;
public abstract class Buffer {
public final int capacity( )
public final int position( )
public final Buffer position (int newPosition)
public final int limit( )
public final Buffer limit (int newLimit)
public final Buffer mark( )
public final Buffer reset( )
public final Buffer clear( )
public final Buffer flip( )
public final Buffer rewind( )
public final int remaining( )
public final boolean hasRemaining( )
public abstract boolean isReadOnly( );
}
支持链式调用，如：buffer.mark().position(5).reset( );
注意isReadOnly()方法决定了buffer是否可写。
下面以IntBuffer类的操作为实例：
代码：
package com.zsc.day02;
import java.nio.IntBuffer;
public class IntBufferDemo {
public static void main(String[] args) {
//声明int类型缓冲区 ，开辟缓冲区大小为10
IntBuffer buf=IntBuffer.allocate(10);
System.out.println("1.写入数据之前：position="+buf.position()+"," +
"limit="+buf.limit()+",capacity="+buf.capacity());
int temp[]={2,3,4,8,3,4};
buf.put(1); //写入数据
buf.put(temp);
System.out.println("2.写入数据之后：position="+buf.position()+"," +
"limit="+buf.limit()+",capacity="+buf.capacity());
buf.flip(); // 重置缓冲区 即position=0，limit=原本position
System.out.println("3.准备输出数据时：position="+buf.position()+"," +
"limit="+buf.limit()+",capacity="+buf.capacity());
//输出缓冲去内容
while(buf.hasRemaining()){
int x=buf.get();
System.out.print(x+" ");
}
}
}
运行结果
1.写入数据之前：position=0,limit=10,capacity=10 2.写入数据之后：position=7,limit=10,capacity=10 3.准备输出数据时：position=0,limit=7,capacity=10 1 2 3 4 8 3 4
如果只开辟了5个缓冲区大小，但是写入了7个数据时，则会发生以下错误：
Exception in thread "main" java.nio.BufferOverflowException代码
package com.zsc.day02;
import java.nio.IntBuffer;
public class IntBufferDemo {
public static void main(String[] args) {
//声明int类型缓冲区 ，开辟缓冲区大小为5
IntBuffer buf=IntBuffer.allocate(5);
System.out.println("1.写入数据之前：position="+buf.position()+"," +
"limit="+buf.limit()+",capacity="+buf.capacity());
int temp[]={2,3,4,8,3,4};
buf.put(1); //写入数据
buf.put(temp);
System.out.println("2.写入数据之后：position="+buf.position()+"," +
"limit="+buf.limit()+",capacity="+buf.capacity());
buf.flip(); // 重置缓冲区 即position=0，limit=原本position
System.out.println("3.准备输出数据时：position="+buf.position()+"," +
"limit="+buf.limit()+",capacity="+buf.capacity());
//输出缓冲去内容
while(buf.hasRemaining()){
int x=buf.get();
System.out.print(x+" ");
}
}
}运行结果
Exception in thread "main" java.nio.BufferOverflowException
at java.nio.HeapIntBuffer.put(HeapIntBuffer.java:183)
at java.nio.IntBuffer.put(IntBuffer.java:832)
at com.zsc.day02.IntBufferDemo.main(IntBufferDemo.java:11)
2、创建子缓冲区：
可以使用各个缓冲区类的slice()方法从一个缓冲区中创建一个新的子缓冲区，子缓冲区与原缓冲区中的部分数据可以共享。
代码：
package com.zsc.day02;
import java.nio.IntBuffer;
import java.nio.IntBuffer;
public class IntBufferDemo02 {
public static void main(String[] args) {
IntBuffer buf=IntBuffer.allocate(10); //声明int类型缓冲区 开辟10个大小缓冲区
IntBuffer sub=null; //定义缓冲区对象
for(int i=0;i<10;i++){
buf.put(2*i+1); //加入10个奇数
}
//创建子缓冲区
buf.position(2); //主缓冲区设置在第三个元素上
buf.limit(6); //主缓冲区limit 为6
sub=buf.slice(); //开辟子缓冲区
for(int i=0;i<sub.capacity();i++){
int temp=sub.get(i); //根据下表去的元素
sub.put(temp-1); //改变子缓冲区内容
}
buf.flip();//重设缓冲区
buf.limit(buf.capacity()); //设置limit
//输出缓冲区内容
while(buf.hasRemaining()){ //只要缓冲区中有数据则输出
int x=buf.get(); // 取出当前内容
System.out.print(x+" ");
}
}
}
运行结果：
1 3 4 6 8 10 13 15 17 19
3、创建只读缓冲区
如果现在要使用到缓冲区中的内容，但又不希望其内容被修改，则可以通过 asReadOnlyBuffer()方法创建一个只读缓冲区，但是创建完毕以后，此缓冲区不能变为可写状态。
代码：
package com.zsc.day02;
import java.nio.IntBuffer;
import java.nio.IntBuffer;
public class IntBufferDemo03 {
public static void main(String[] args) {
IntBuffer buf=IntBuffer.allocate(10); //声明int类型缓冲区 开辟10个大小缓冲区
IntBuffer readOnly=null;
for(int i=0;i<10;i++){
buf.put(2*i+1);
}
//创建子缓冲区
buf.position(2);
buf.limit(6);
readOnly=buf.asReadOnlyBuffer();
readOnly.flip();//重设缓冲区
readOnly.limit(buf.capacity());
//输出缓冲区内容
while(readOnly.hasRemaining()){
int x=readOnly.get();
System.out.print(x+" ");
}
System.out.println();
// readOnly.put(30); //错误不可写
}
}
运行结果：
1 3 5 7 9 11 13 15 17 19
4、直接创建缓冲区：
只缓冲区操作中，只有ByteBuffer 可以创建直接缓冲区，这样java虚拟机将尽最大努力直接对其执行本机的IO操作。
创建方法：public static ByteBuffer allocateDirect(int capacity)
代码：
package com.zsc.day02;
import java.nio.ByteBuffer;
public class ByteBufferDemo {
public static void main(String[] args) {
//声明ByteBuffer 对象
ByteBuffer buf = null ;
//直接开辟缓冲区
buf = ByteBuffer. allocateDirect(10);
byte temp[]={2,3,4,5,6,8,1}; //定义 byte数组
buf.put(temp); //向缓冲区中 写入一组数据
buf.flip(); //重设缓冲区
System.out.println("缓冲区中的内容：");
while(buf.hasRemaining()){
int x=buf.get();
System.out.print(x+" ");
}
}
}
运行结果：
缓冲区中的内容：
2 3 4 5 6 8 1
二、通道
通道（Channel）可以用来读取和写入数据，通道类似于之前的输入输出，但是程序不会直接操作通道，所有的内容都是先读到或写入到缓冲区中，在通过缓冲区中取得或写入的。
通道与传统的流操作不同，传统的流操作分为输入流或输出流，而通道本身是双向的，既可以完成输入也可以完成输出。
Channel 本身是一个接口。
1、FileChannel
FileChannel 是Channel 的子类，可以进行文件的读/写操作。
使用通道进行读写操作：
代码：
package com.zsc.day02;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileChannelTest {
public static void main(String[] args) throws Exception {
File f1 = new File("d:"+File.separator+"Hello.java");
File f2 = new File("d:"+File.separator+"outHello.java");
FileInputStream fis = null ;//文件输入流
FileOutputStream fos = null ;//文件输出流
fis = new FileInputStream(f1);//实例化输入流
fos = new FileOutputStream(f2);//实例化输出流
FileChannel fin = null ;//声明输入的通道对象
FileChannel fon = null ;//声明输出的通道对象
fin = fis.getChannel();//得到输入的文件通道
fon = fos.getChannel();//得到输出的文件通道
ByteBuffer buf = ByteBuffer.allocate(1024);//开辟缓冲
int temp = 0 ;//声明变量接收的内容
while((temp=fin.read(buf))!=-1){//如果没读到底
buf.flip();//重设缓冲区
fon.write(buf);//输出缓冲区
buf.clear();//清空缓冲区
}
fin.close();//关闭输入流
fon.close();//关闭输出流
fis.close();//关闭输入通道
fos.close();//关闭输出通道
}
}
2、内存映射：
内存映射可以把文件映射到内存中，这样文件内的数据就可以用内存读/写指令来访问，而不是用IputStream 或OutputStream这样的I/O操作类，采用此种方式读取文件的速度是最快的。
java 中访问文件内容的4种方式。
RandomAccessFile ,随机读取数据，此种访问速度最慢;
FileInputStream,文件输入流，使用此种方式速度较慢;
缓冲读取（例如 BufferedReader）此种访问速度较快;
内存映射（MappedByteBuffer）,使用此种方式读取速度最快。
代码：
package com.zsc.day02;
import java.io.File;
import java.io.FileInputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class ChannelTest {
public static void main(String[] args) throws Exception {
File file = new File("d:"+File.separator+"Hello.java");
FileInputStream fis = null ; //文件输入流
fis = new FileInputStream(file); //实例化输入流
FileChannel fin = null ; //声明输入的通道对象
fin = fis.getChannel(); //得到输入文件通道
MappedByteBuffer mbb = null ; //声明文件的内存映射
//将文件映射到内存中
mbb = fin.map(FileChannel.MapMode.READ_ONLY, 0, file.length());
byte data[] = new byte[(int)file.length()]; //开辟字节数组，接收数据
int foot = 0 ; //定义下标
while(mbb.hasRemaining()){ //判断数否有数据
data[foot++] = mbb.get(); //取出数据
}
System.out.println(new String(data)); //显示输入的数据
fis.close(); //关闭输入流
fin.close(); //关闭输入通道
}
}
运行结果：
public calss Hello{
public static void mian(String args[]){
System.out.println("hello");
}
}
注意：尽管创建内存映射文件非常简单，但是如果使用MappedByteBuffer 写入数据就可能非常危险。因为仅仅是改变数组中的单个元素内容这样的操作简单，就有可能直接修改磁盘上的具体文件，因为修改数据与数据重新保存到磁盘是一样的。
三、文件锁：FileLock
在java 新io中提供了文件所得功能，这样当一个线程将文件锁定以后，其他线程是无法操作此文件的。要想进行文件的锁定，则要使用FileLock 类来完成，此类的对象需要依靠FileChannel 进行实例化。
文件锁定的两种方式：
共享锁：允许多个线程进行文件的读取操作；
独占所：只允许一个线程进行文件的读/写操作
文件锁定：
以下程序在运行时将文件进行独占锁定，这样其他线程在锁定的30庙内是无法对此文件进行读写操作的。
代码：
package com.zsc.day02;
import java.io.File;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
public class FileLockTest {
public static void main(String[] args) throws Exception {
File file = new File("d:"+File.separator+"Hello.java");
FileOutputStream fos = null ;
fos = new FileOutputStream(file,true);
FileChannel fon = null ;
fon = fos.getChannel();
FileLock fl = fon.tryLock();
if(fl != null){
System.out.println(file.getName()+"文件锁定30秒。");
Thread.sleep(30000);
fl.release();
System.out.println(file.getName()+"文件解除锁定。");
}
fos.close();
fon.close();
}
}
运行结果：
Hello.java文件锁定30秒。 Hello.java文件解除锁定。
四、字符集：Charset
在java语言中所有的信息都是以UNICODE 进行编码的，但是在计算机的世界里面并不是但存在一种编码，而是多个，而且如果对编码处理不当，就有可能引起乱码的产生。在java的新IO包中提供了Charset 类来负责处理编码的问题，该类还包含了创建编码器（CharsetEncoder）和创建解码器（CharsetDecoder）的操作。
1、获取Charset 类的全部编码：
代码：
package com.zsc.day02;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Map;
import java.util.SortedMap;
public class GetAllCharset {
public static void main(String[] args) {
SortedMap<String,Charset> all = null ; //声明 SortedMap 集合
all = Charset.availableCharsets(); //获取全部编码
Iterator<Map.Entry<String,Charset>> iter = null ; //声明 Iterator 对象
iter = all.entrySet().iterator(); //实例化 Iterator
while(iter.hasNext()){ //迭代输出
Map.Entry<String, Charset> me = iter.next(); //取出每一个Map.Entry
System.out.println(me.getKey()+"---->"+me.getValue()); //输出信息
}
}
}
运行结果
Big5---->Big5 Big5-HKSCS---->Big5-HKSCS EUC-JP---->EUC-JP EUC-KR---->EUC-KR GB18030---->GB18030 GB2312---->GB2312 GBK---->GBK IBM-Thai---->IBM-Thai IBM00858---->IBM00858 IBM01140---->IBM01140 IBM01141---->IBM01141 IBM01142---->IBM01142 ...
2、 解码编码操作：
代码：
package com.zsc.day02;
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;
public class CharsetEnDeTest {
public static void main(String[] args) throws Exception {
Charset latin1 = Charset.forName("ISO-8859-1");
CharsetEncoder encoder = latin1.newEncoder();
CharsetDecoder decoder = latin1.newDecoder();
//通过CharBuffer 类中的 wrap()方法，将一个字符串变为CharBuffer 类型
CharBuffer cb = CharBuffer.wrap("圣诞快乐");
ByteBuffer buf = encoder.encode(cb);
System.out.println(decoder.decode(buf));
}
}
运行结果：
Exception in thread "main" java.nio.charset.UnmappableCharacterException: Input length = 1
at java.nio.charset.CoderResult.throwException(CoderResult.java:278)
at java.nio.charset.CharsetEncoder.encode(CharsetEncoder.java:798)
at com.zsc.day02.CharsetEnDeTest.main(CharsetEnDeTest.java:17)
注意：运行以后将以"ISO-8859-1"的编码方式显示中文，这样肯定是无法正常显示的，所以之后的解码操作都会造成乱码，一般CharsetEncoder 和CharsetDecoder 都经常使用在文件的读写上，已实现文件编码的转换功能。
五、Selector
在原来使用的IO和Socket 构造网络服务时，所有的网络服务将使用阻塞的方式进行客户端的连接，而如果使用新IO则可以构造一个非阻塞的网络服务。
下面使用Selector 创建一个非阻塞的服务器，此服务器向客户端返回当前的系统时间。
代码：
package com.zsc.day02;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
public class DateServer {
public static void main(String[] args) throws Exception { //所有异常抛出
int ports[] = {8000,8001,8002,8003,8004,8005,8006,8007,8008}; //定义一组连接端口
Selector selector = Selector.open(); //打开一个选择器
for(int i = 0 ;i<ports.length;i++){ //构造服务器的启动消息
ServerSocketChannel initSer = null ; //声明CharSocketChannel
initSer = ServerSocketChannel.open(); //打开服务器套接字通道
initSer.configureBlocking(false); //服务器配置为非阻塞
ServerSocket initSock = initSer.socket(); //检索与此通道关联的服务器套接字
InetSocketAddress address = null ; //表示监听地址
address = new InetSocketAddress(ports[i]); //实例化绑定地址
initSock.bind(address); //绑定地址
//注册选择器，相当于使用accept（） 方法接收
initSer.register(selector, SelectionKey.OP_ACCEPT); //
System.out.println("服务器运行，在"+ports[i]+"端口监听。"); //
}
int keysAdd = 0 ; //
while((keysAdd=selector.select())>0){ //接收一组SelectionKey
Set<SelectionKey> selectedKeys = selector.selectedKeys(); //选择一组键，相应的通道以为IO准备就绪
//取出全部生成的key
Iterator<SelectionKey> iter = selectedKeys.iterator();
while(iter.hasNext()){ //迭代全部的key
SelectionKey key = (SelectionKey)iter.next(); //
if(key.isAcceptable()){ //取出每一个Selectionkey,判断客户端是否已经连接上
ServerSocketChannel server = (ServerSocketChannel)key.channel(); //取得 Channel
SocketChannel client = server.accept(); //接收新连接
client.configureBlocking(false); //设置非阻塞状态
ByteBuffer outBuf = ByteBuffer.allocateDirect(1024); //开辟缓冲去
outBuf.put(("当前时间为："+new Date()).getBytes()); //向缓冲区设置内容
outBuf.flip(); //重置缓冲区
client.write(outBuf); //输出信息
client.close(); //关闭输出流
}
}
selectedKeys.clear(); //清除全部的key
}
}
}
运行结果：
以上程序运行后，程序将在8000,8001,8002,8003,8004,8005,8006,8007,8008 8 个端口进行监听进行服务器的监听，等待客户端连接，刻度连接后将返回系统的当前时间
在浏览器输入：http://127.0.0.1:8001
将返回：
当前时间为：Sat Dec 24 16:54:57 CST 2011