java 中的NIO

NIO

概念

NIO： New IO。 Non-Blocking IO。

NIO 是JDK1.4的时候出现了⼀个新的IO， ⽤来替代传统的IO流。 NIO与IO有着相同的功能， 但是操作的⽅法不同。Java提供了⼀些改进输⼊/输出处理的新功能,这些新功能被统称为新IO(New IO 简称NIO),新增了许多⽤于处理输⼊/输出的类,这些类都被放在java.nio包以及⼦包下,并对原java.io中的很多类都以NIO为基础进⾏改写,新增了满⾜NIO的功能
NIO是基于通道(Channel)， ⾯向缓冲区(Buffer)的。
在JDK1.7的时候， 为NIO添加了⼀些新的特定。 被称为 NIO.2

Java NIO 由以下⼏个核⼼部分组成:
Channels：通道 Buffer：缓冲区 Selectors：选择器
Channels和Buffer是新IO中的两个核⼼对象,Channel是对传统的输⼊/输出系统的模拟,在新IO系统中所有的数据都需要通过通道传输。
Channels与传统的InputStream,OutputStrem最⼤的区别在于它提供了⼀个map()⽅法,通过该map()⽅法可以直接将"⼀块数据"映射到内存中,如果说传统的输⼊/输出系统是⾯向流处理,则新IO则是⾯向块的处理
Buffer可以被理解为⼀个容器(缓冲区,数组),发送到Channel中的所有对象都必须⾸先放到Buffer中,⽽从Channel中读取的数据也必须放到Buffer中,也就是说数据可以从Channel读取到Buffer中,也可以从Buffer写到Channel中

和传统的IO的区别

1.IO⾯向流,NIO⾯向缓冲区
Java IO⾯向流意味着每次从流中读⼀个或多个字节，直⾄读取所有字节，它们没有被缓存在任何地⽅。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到⼀个缓冲区。 Java NIO的缓冲导向⽅法略有不同。数据读取到⼀个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性.
2.IO是阻塞式的,NIO有⾮阻塞式的
Java IO的各种流是阻塞的。这意味着，当⼀个线程调⽤read() 或 write()时，该线程被阻塞，直到有⼀些数据被读取，或数据完全写⼊。该线程在此期间不能再⼲任何事情了。Java NIO的⾮阻塞模式，使⼀个线程从某通道发送请求读取数据，但是它仅能得到⽬前可⽤的数据，如果⽬前没有数据可⽤时，就什么都不会获取，⽽不是保持线程阻塞所以直⾄数据变的可以读取之前，该线程可以继续做其他的事情。 ⾮阻塞写也是如此。
3.IO没有选择器,NIO有选择器
Java NIO的选择器允许⼀个单独的线程来监视多个输⼊通道，你可以注册多个通道使⽤⼀个选择器，然后使⽤⼀个单独的线程来“选择”通道：这些通道⾥已经有可以处理的输⼊，或者选择已准备写⼊的通道。这种选择机制，使得⼀个单独的线程很容易来管理多个通道.

Buffer缓冲区

缓冲区的概念

其实是⼀个⽤来存储基本数据类型的⼀个容器， 类似于⼀个数组。
缓冲区， 可以按照存储的数据类型不同， 将缓冲区分为:
ByteBuffer、 ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer、CharBuffer
但是， 要注意， 并没有BooleanBuffer！
这些缓冲区， 虽然是不同的类， 但是他们拥有的相同的属性和⽅法。 因为他们都继承⾃相同的⽗类 Buffer。

Buffer的⼏个属性

capacity: 容量。 代表⼀个缓冲区的最⼤的容量， 缓冲区⼀旦开辟完成， 将⽆法修改。
limit: 限制。 表示缓冲区中有多少数据可以操作。
position: 位置。 表示当前要操作缓冲区中的哪⼀个下标的数据。
mark: 标记。 在缓冲区中设计⼀个标记， 配合 reset() ⽅法使⽤， 修改position的值。

mark <= position <= limit <= capacity

Buffer常⽤的⽅法

注意事项

在向缓冲区中写数据的时候， 要注意： 不要超出缓冲区的范围。 如果超出范围了， 会出现BufferOverflowException异常， 且本次put的所有数据都不会存⼊到缓冲区中。

缓冲区， 其实有两种模式： 分别是读模式和写模式。
读模式： 就是从缓冲区中读取数据。
写模式: 就是将数据写⼊到缓冲区。
⼀个刚刚被开辟的缓冲区， 默认处于写模式。

缓冲区的详解

其实， 缓冲区中， 并没有所谓的读模式和写模式。 其实所谓“读模式”和“写模式”，只是逻辑上的区分。
⼀个处于“读模式”下的缓冲区， 依然可以写数据。 ⼀个处理“写模式”下的缓冲区，依然可以读取数据。
上述⽅法中， 基本所有的⽅法， 都是围绕着缓冲区中的⼏个属性进⾏的。

ByteBuffer buffer = ByteBuffer.allocate(1024);//开辟容量1024字节
System.out.println("position:"+buffer.position());//0
System.out.println("limit:"+buffer.limit());//1024
buffer.put("hello".getBytes());
System.out.println(buffer.position());//5
System.out.println(buffer.limit());//1024
//可以继续写
buffer.put("world".getBytes());//buffer.position()10
//切换为读模式
/*这⼀步很重要 flip可以理解为模式切换 之前的代码实现的是写⼊操作
*当调⽤这个⽅法后就变成读取操作,那么position和limit的值就要发⽣
变换
*此时capacity为1024不变
*此时limit就移动到原来position所在的位置,相当于把buffer中没有
数据的空间
*"封印起来"从⽽避免读取Buffer数据的时候读到null值
*相当于 limit = position limit = 10
*此时position的值相当于 position = 0
*
*/
buffer.flip();
// //获取单个字节
// //buffer.get();
// //获取多个字节
byte[] data=new byte[buffer.limit()];
buffer.get(data);
System.out.println("data:"+new String(data));
System.out.println("读取data后:"+buffer.position());//从0
变成了10,position相当于读字节的指针,内容读完了指到了结尾
System.out.println("读取data后:"+buffer.limit());
//将position设回0，所以你可以重读Buffer中的所有数据。limit保持不变，仍然表示能从Buffer中读取多少个元素
/*
* clear():
* API中的意思是清空缓冲区,但是实际是没有删除缓冲区数据的
* ⽽是将缓冲区中limit和position恢复到初始状态
* 即limit和capacity都为1024 position是0
* 此时可以完成写⼊模式
*/
// buffer.clear();

直接缓冲区

⾮直接缓冲区， 是在JVM中开辟的空间。 allocate(int capacity)
直接缓冲区， 是直接在物理内存上开辟的空间。allocateDirect(int capacity)

对于⼀个已经存在的缓冲区， 可以使⽤ isDirect() ⽅法， 判断是否是直接缓冲区。 这个⽅法的返回值类型是boolean类型的， 如果是true, 就表示是⼀个直接缓冲区。 如果是false， 就表示不是⼀个直接缓冲区。

Channel通道

通道的简介

通道Channel， 就是⽂件和程序之间的连接。 在NIO中， 数据的传递， 是由缓冲区实现的， 通道本身并不负责数据的传递。
通道在 java.nio.channels 包中， 常⻅的Channel⼦类：
本地⽂件: FileChannel
⽹络⽂件: SocketChannel, ServerSocketChannel, DatagramChannel

Channel类似于传统的流对象,但与传统的流对象有两个主要的区别:
Channel可以直接将我指定⽂件的部分或全部直接映射成Buffer
程序不能直接访问Channel中的数据,包括读取,写⼊都不⾏.Channel只能与Buffer进⾏交互

通道的打开⽅式

可以使⽤⽀持通道的类， getChannel()⽅法获取通道。

1. 本地⽂件: FileInputStream、FileOutputStream
2. ⽹络⽂件: Socket、ServerSocket、DatagramSocket

在NIO.2中， 使⽤FileChannel.open()⽅法打开通道。

在NIO.2中， 使⽤Files⼯具类newXXX()⽅法打开通道。

使⽤FileChannel读写数据

在使⽤FileChannel之前，必须先打开它。但是，我们⽆法直接打开⼀个FileChannel，需要通过使⽤⼀个InputStream、OutputStream的getChannel()⽅法来返回对应的Channel

/*
使用通道和缓冲区完成拷贝
 */
public class Demo {
    public static void main(String[] args) throws IOException {
        //创建读通道
        FileChannel inChannel = FileChannel.open(Paths.get("BD2102java_day0809\\file\\temp1.txt"), StandardOpenOption.READ);
        //创建写通道
        FileChannel outChannel = FileChannel.open(Paths.get("BD2102java_day0809\\file\\temp2.txt"), StandardOpenOption.WRITE,StandardOpenOption.CREATE);
        //创建缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        int num = 0;
        while ((num = inChannel.read(byteBuffer)) != -1){
            //切换模式
            byteBuffer.flip();
            outChannel.write(byteBuffer);
            //切回写模式
            byteBuffer.clear();
        }

        inChannel.close();
        outChannel.close();
        System.out.println("复制完毕");
    }
  }
}

分散聚合

分散写， 聚合读。
将⽂件中的数据分散的写⼊到多个缓冲区， 这些缓冲区按照⼀定的顺序进⾏数据的写⼊。 在读取的时候， 也按照相同的顺序进⾏数据的读操作。

NIO2

简介

Java7对原有NIO进⾏了重⼤改进,改进主要包括如下两个⽅⾯的内容
1.提供了全⾯的⽂件IO和⽂件系统访问⽀持
2.基于异步Channel的IO
Path、Paths和Files
之前学习中学习过File类来访问⽂件系统,但是File类的功能⽐较有限,NIO.2为了弥补这种不⾜,引⼊了⼀个Path接⼝还提供了Files和Paths两个⼯具类,其中Files封装了包含⼤量静态⽅法来操作⽂件,Paths则包含了返回Path的静态⼯⼚⽅法

Files使⽤示例代码

public class FilesUsage {
public static void main(String[] args) throws IOException {
// 1. 创建⼀级⽂件夹(如果这个⽂件夹存在，会抛异常)
//
Files.createDirectory(Paths.get("C:\\Users\\luds\\Desktop\\abc")
);
// 2. 创建多级⽂件夹(如果需要创建的⽂件夹存在，不会抛出异常)
//
Files.createDirectories(Paths.get("C:\\Users\\luds\\Desktop\\abc
\\a\\b\\c"));
// 3. 创建⼀个⽂件(如果这个⽂件已存在，重复创建会异常)
//
Files.createFile(Paths.get("C:\\Users\\luds\\Desktop\\abc\\file"
));
// 4. 删除⼀个⽂件或者空⽂件夹(如果要删除的⽂件或空⽂件夹不存在，
会抛异常；如果删除的不是⼀个空⽂件夹也会抛异常)
//
Files.delete(Paths.get("C:\\Users\\luds\\Desktop\\abc\\file"));
// 5. 删除⼀个⽂件或者空⽂件夹(如果删除失败，不会抛异常，返回
false)
//
Files.deleteIfExists(Paths.get("C:\\Users\\luds\\Desktop\\abc\\f
ile"));
// 6. 移动⽂件(重命名)
// Files.move(Paths.get("file\\day28\\source"),
Paths.get("file\\day28\\dst\\source"));
// 7. 拷⻉⽂件
 Files.copy(Paths.get("file\\day28\\dst\\source"),
Paths.get("file\\day28\\source"));
	}
}

NIO2使⽤示例代码

//⼀次读取⽂件中所有的⾏
List<String> readAllLines =
Files.readAllLines(Paths.get("src/com/qiangfeng/test/Demo1.java"
));
for (String str : readAllLines) {
System.out.println("haha:"+str);
}
//将集合中的内容写⼊到⽂件中
Files.write(Paths.get("D:\\", "123","Demo.java"),
readAllLines);

使⽤FileVisitor遍历⽂件和⽬录

- 在以前的Java版本中,如果程序要遍历指定⽬录的所有⽂件和⼦⽬录,则只能使⽤递归进⾏遍历,
- 但这种⽅法不仅复杂,⽽且灵活性也不⾼,有了Files⼯具类的帮助,现在可以使⽤更优雅的⽅式来遍历和⼦⽬录

public class Demo8 {
	public static void main(String[] args) throwsIOException {
        /*
        * FileVisitor参数代表的是⼀个⽂件访问器,walkFileTree()⽅法会⾃动遍历
        * start路径下的所有⽂件和⼦⽬录,遍历⽂件和⼦⽬录都会触发FileVisitor中相应的⽅法
        * FileVisitResult postVisitDirectory(T dir,IOException exc)访问⼦⽬录之后会触发这个⽅法
        FileVisitResult preVisitDirectory(T dir,
        BasicFileAttributes attrs)访问⼦⽬录之前会触发这个⽅法
        FileVisitResult visitFile(T file,
BasicFileAttributes attrs)访问file⽂件时触发该⽅法
        FileVisitResult visitFileFailed(T file,
IOException exc)访问file⽂件失败时触发该⽅法返回FileVisitResult是⼀个枚举
        CONTINUE 代表继续访问的后续⾏为
        SKIP_SIBLINGS 代表继续访问的后续⾏为,但不访问该⽂件后⽬录的兄弟⽂件或⽬录
        SKIP_SUBTREE 代表继续访问的后续⾏为,但不访问该⽂件或⽬录的⼦⽬录树
        TERMINATE 代表终⽌访问的后续⾏为实际开发中没有必要4个⽅法都要重写,可以通过FileVisitor的⼦类SimpleFileVisitor(适配器)来创建⾃⼰的⽂件访问器,选择性的重写⽅法
        */
		//遍历⽂件
Files.walkFileTree(Paths.get("D:\\workspace\\BigDataNIO"), new SimpleFileVisitor<Path>() {
		//访问⽂件时触发该⽅法
	@Override
	public FileVisitResult visitFile(Path file,
BasicFileAttributes attrs) throws IOException {
		System.out.println("正在访问"+file+"⽂件");
		// if(file.endsWith("MergeSort.java")) {
		// System.out.println("--找到了⽂件--");
		// return FileVisitResult.TERMINATE;
		// }
		return FileVisitResult.CONTINUE;
	}
//开始访问⽬录时触发的⽅法
	@Override
	public FileVisitResult preVisitDirectory(Path
dir, BasicFileAttributes attrs) throws IOException {
		System.out.println("正在访问"+dir+"路径");
		return FileVisitResult.CONTINUE;
	}
	});
  }
}