相比以前IO而言:两者最重要的区别就是在数据打包和传输方式上有不同,IO以流的方式传输数据,NIO以块的方式传输数据。
面向流的I/O系统一次一个字节地处理数据。一个输入流产生一个字节的数据,一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器,以便每个过滤器只负责单个复杂处理机制的一部分,这样也是相对简单的。不利的一面是,面向流的I/O通常相当慢。
NIO与原来的I/O有同样的作用和目的,但是它使用块I/O的处理方式。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的I/O缺少一些面向流的I/O所具有的优雅性和简单性。
通道和缓冲区
在NIO中所有的数据都是利用缓冲区(Buffer)进行处理的,缓冲区是一个容器对象,它包含一些要写入或者读取的数据,在IO中,可以将数据写入或者读取的stream对象中。
缓冲区实际上为一个数组,通常为一个字节数组。而且它也提供了对数据结构化的访问,并且跟踪系统的读写进程。
举例来说:ByteBuffer,ByterBuffer是一个最常用的缓冲区,可以利用get/put对底层字节数组进行获取和设置。
public abstract class ByteBuffer
extends Buffer
implements Comparable<ByteBuffer>
{
final byte[] hb; // Non-null only for heap buffers
final int offset;
boolean isReadOnly; // Valid only for heap buffers
设置put,重载了多个put方法,取一种
public ByteBuffer put(byte[] src, int offset, int length) {
checkBounds(offset, length, src.length);
if (length > remaining())
throw new BufferOverflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
this.put(src[i]);
return this;
}
获取ByteBuffer间的元素
public ByteBuffer get(byte[] dst, int offset, int length) {
checkBounds(offset, length, dst.length);
if (length > remaining())
throw new BufferUnderflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
dst[i] = get();
return this;
}
例:
/**
* ByteBuffer测试
*/
public static void testFloatBuffer() throws Exception {
// 分配一个容量为10的float缓冲区
ByteBuffer buffer = ByteBuffer.allocate(10);
for (int i = 0; i < buffer.capacity(); i++) {
buffer.put((byte)(i));
}
// 反转缓冲区
buffer.flip();
// 告知在当前位置和限制之间是否存在元素
while (buffer.hasRemaining()) {
System.out.println(buffer.get());
}
}
通道Channel是对原IO包中流的模拟,可以通过它读取或者写入数据。通道相对于流而言,通道是双向的,通道可以用于读、写或者同时进行读写,而流只是在一个方向上流动。
NIO中数据的读/写:
读:创建一个缓冲区,然后利用通道将数据读取到该缓冲区中即可。
/**
* 读取一个文件的前1024个字符
*/
public static void getFileContent(File file) throws Exception {
FileInputStream fis=new FileInputStream(file);
FileChannel cin=fis.getChannel();
//创建一个容量为1024的字节缓冲区
ByteBuffer buffer=ByteBuffer.allocate(1024);
//利用通道将数据写入到缓冲区
cin.read(buffer);
System.out.println(new String(buffer.array()));
cin.close();
fis.close();
}
写:创建一个缓冲区,然后填充数据,后利用通道用该数据进行写入操作。
/**
* 写入文件
*/
public static void writeFileContent(String filePath) throws Exception {
File file = new File(filePath);
FileOutputStream fos = null;
FileChannel cout = null;
if (!file.exists()) {
file.createNewFile();
}
//通过FileOutputStream获取缓冲区
fos = new FileOutputStream(file);
cout = fos.getChannel();
//创建一个byte缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
//往byte缓冲区中存入数据
for (int i = 0; i < 9; i++) {
buffer.put((byte)(i+'A'));
}
//反转缓冲区,必须写,如果没有,则是从文件最后开始读取的,通过这个能将buffer当前位置position更改为
//buffer缓冲区的第一个,这样才能对buffer进行遍历读取
buffer.flip();
//利用FileChannel执行写入操作
cout.write(buffer);
cout.close();
fos.close();
}
文件的拷贝:
/**
* 文件的拷贝
*/
public static void copyFile(File source, File target) throws Exception {
FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(target);
FileChannel cin = fis.getChannel();
FileChannel cout = fos.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int temp = 0;
while ((temp = cin.read(buffer)) != -1) {
buffer.flip();
cout.write(buffer);
// 重置buffer
buffer.clear();
}
closeResource(fis,fos,cin,cout);
}
/**
* 关闭流和通道
*/
public static void closeResource(FileInputStream fis, FileOutputStream fos,
FileChannel cin, FileChannel cout) throws Exception {
if (cin != null) {
cin.close();
}
if (cout != null) {
cout.close();
}
if (fis != null) {
fis.close();
}
if (fos != null) {
fos.close();
}
}