HelloWorld
登录

Java NIO学习笔记

Wesley13

2021-10-11

1434 0 0

Java NIO是什么

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

Java NIO 与 IO 的主要区别

IO

NIO

面向流(Stream Oriented)

面向缓冲区(Buffer Oriented)

阻塞IO(Blocking IO)

非阻塞IO(Non Blocking IO)

(无)

选择器(Selectors)

缓冲区（ Buffer）

一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(boolean 除外) ，有以下 Buffer 常用子类：

  • ByteBuffer
  • CharBuffer
  • ShortBuffer
  • IntBuffer
  • LongBuffer
  • FloatBuffer
  • DoubleBuffer

上述 Buffer 类 他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。

缓冲区的基本属性
  • 容量 (capacity) :表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改.
  • 限制 (limit):第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
  • 位置 (position):下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制.
  • 标记 (mark)与重置 (reset):标记是一个索引，通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position，之后可以通过调用 reset()方法恢复到这个 position.

标记、 位置、 限制、 容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity

缓冲区的数据操作

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

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

1public class TestBuffer {
2
3	@Test
4	public void test1() {
5		//分配指定大小的缓冲区
6		ByteBuffer buffer = ByteBuffer.allocate(1024);
7		System.out.println(buffer.position());//0 返回缓冲区的当前位置 position
8		System.out.println(buffer.limit());//1024 返回 Buffer 的界限(limit) 的位置
9		System.out.println(buffer.capacity());//1024 返回Buffer的capacity 大小
10		//将数据存入缓冲区
11		buffer.put("abcde".getBytes());
12		
13		System.out.println(buffer.position());//5
14		System.out.println(buffer.limit());//1024
15		System.out.println(buffer.capacity());//1024
16		//切换到读取数据的模式
17		buffer.flip();
18		
19		System.out.println(buffer.position());//0
20		System.out.println(buffer.limit());//5
21		System.out.println(buffer.capacity());//1024
22		//读取缓冲区的数据
23		byte[] bs = new byte[buffer.limit()];
24		buffer.get(bs);
25		System.out.println(new String(bs, 0, bs.length));//abcde
26		
27		System.out.println(buffer.position());//5
28		System.out.println(buffer.limit());//5
29		System.out.println(buffer.capacity());//1024
30		//回到读模式，可重复读数据
31		buffer.rewind();//将位置设为为 0， 取消设置的 mark
32		
33		System.out.println(buffer.position());//0
34		System.out.println(buffer.limit());//5
35		System.out.println(buffer.capacity());//1024
36		//清空缓冲区，回到最初状态。但是缓冲区的数据还在，处于被遗忘状态。
37		buffer.clear();//清空缓冲区并返回对缓冲区的引用
38		System.out.println(buffer.position());//0
39		System.out.println(buffer.limit());//1024
40		System.out.println(buffer.capacity());//1024
41	}
42	
43	@Test
44	public void test2() {
45		String str = "abcde";
46		ByteBuffer buffer = ByteBuffer.allocate(1024);
47		buffer.put(str.getBytes());
48		
49		System.out.println(buffer.position());//5
50		System.out.println(buffer.limit());//1024
51		System.out.println(buffer.capacity());//1024
52		
53		buffer.flip();
54		
55		byte[] bs = new byte[buffer.limit()];
56		buffer.get(bs, 0, 2);
57		System.out.println(new String(bs, 0, 2));//ab
58		
59		System.out.println(buffer.position());//2
60		System.out.println(buffer.limit());//5
61		System.out.println(buffer.capacity());//1024
62		//标记position的位置
63		buffer.mark();
64		
65		buffer.get(bs, 2, 2);
66		System.out.println(new String(bs, 2, 2));//cd
67		
68		System.out.println(buffer.position());//4
69		//重置position的位置到标记的地方
70		buffer.reset();
71		
72		System.out.println(buffer.position());//2
73		//缓冲区中是否还有课操作的字节
74		if (buffer.hasRemaining()) {
75			//剩余可操作的字节数
76			System.out.println(buffer.remaining());//3 返回 position 和 limit 之间的元素个数
77		}
78	}
79	
80	@Test
81	public void test3() {
82		//创建直接缓冲区
83		ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
84		//判断是否为直接缓冲区
85		System.out.println(buffer.isDirect());//true
86	}
87}

直接与非直接缓冲区

  1. 字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
  2. 直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
  3. 直接字节缓冲区还可以通过 FileChannel 的 map() 方法将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer。Java 平台的实现有助于通过 JNI从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。
  4. 字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

通道Channel

通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。**Channel 负责传输， Buffer 负责存储。**通道是由 java.nio.channels 包定义的。 Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据， Channel 只能与Buffer 进行交互。

Java 为 Channel 接口提供的最主要实现类
  • FileChannel：用于读取、写入、映射和操作文件的通道。
  • DatagramChannel：通过 UDP 读写网络中的数据通道。
  • SocketChannel：通过 TCP 读写网络中的数据。
  • ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
获取通道

获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下：

  • FileInputStream
  • FileOutputStream
  • RandomAccessFile
  • DatagramSocket
  • Socket
  • ServerSocket

获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道。

通道的数据传输
1//通道用于源节点与目标节点之间的连接，在NIO中负责缓冲区中数据的传输。
2//Channel本身不存储数据，需要配合缓冲区进行数据传输
3/**
4 * 通道的主要实现类
5 * java.nio.channels.Channel接口
6 * 		|--FileChannel
7 * 		|--SocketChannel
8 * 		|--ServerSocketChannel
9 * 		|--DatagramChannel
10 *
11 * 获取通道
12 * 1.Java针对支持通道的类提供了getChannel()方法
13 * 		本地IO：
14 * 			FileInputStream/FileOutputStream
15 * 			RandomAccessFile
16 * 
17 * 		网络IO：
18 * 			Socket
19 * 			ServerSocket
20 * 			DatagramSocket
21 * 
22 * 2.在JDK1.7中NIO.2针对各个通道提供了静态方法open()
23 * 3.在JDK1.7中NIO.2的Files工具类的newByteChannel()
24 */
25
26
27public class TestChannel {
28	//利用通道完成文件的复制(非直接缓冲区)
29	@Test
30	public void test1() {
31		//26088
32		//6479
33		//6587
34		//6464
35		long start = System.currentTimeMillis();
36		FileInputStream fileInputStream = null;
37		FileOutputStream fileOutputStream = null;
38		FileChannel inChannel = null;
39		FileChannel outChannel = null;
40		try {
41			fileInputStream = new FileInputStream("E:\\BaiduYunDownload\\juc.zip");
42			fileOutputStream = new FileOutputStream("F:\\juc_copy2.zip");
43			//获取通道
44			inChannel = fileInputStream.getChannel();
45			outChannel = fileOutputStream.getChannel();
46			//分配指定大小的缓冲区
47			ByteBuffer buffer = ByteBuffer.allocate(1024);
48			//将通道中的数据存入缓冲区
49			while (inChannel.read(buffer) != -1) {
50				//切换成读取数据模式
51				buffer.flip();
52				//将缓冲区中的数据写入通道中
53				outChannel.write(buffer);
54				//清空缓冲区
55				buffer.clear();
56			}
57		} catch (Exception e) {
58			// TODO Auto-generated catch block
59			e.printStackTrace();
60		} finally {
61			//关闭通道 省略if判断
62			outChannel.close();
63			inChannel.close();
64			//关闭流
65			fileOutputStream.close();
66			fileInputStream.close();
67		}
68		long end = System.currentTimeMillis();
69		System.out.println(end - start);
70	}
71	
72	@Test
73	public void test2() throws IOException {
74		//1190
75		//5144
76		//5932
77		//1316
78		//1126
79		//998
80		//1242
81		long start = System.currentTimeMillis();
82		//使用直接缓冲区完成文件的复制（内存映射文件）
83		//只有ByteBuffer支持直接缓冲区
84		FileChannel inChannel = FileChannel.open(Paths.get("E:\\BaiduYunDownload\\", "juc.zip"), StandardOpenOption.READ);
85		//StandardOpenOption.CREATE_NEW若存在则报错
86		//StandardOpenOption.CREATE若存在则覆盖
87		FileChannel outChannel = FileChannel.open(Paths.get("F:/", "juc-3.zip"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
88		//内存映射文件。缓冲区在物理内存中。
89		MappedByteBuffer inMappedByteBuffer = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
90		MappedByteBuffer outMappedByteBuffer = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
91		
92		//直接对缓冲区进行数据读写操作
93		byte[] dst = new byte[inMappedByteBuffer.limit()];
94		inMappedByteBuffer.get(dst);
95		outMappedByteBuffer.put(dst);
96		
97		inChannel.close();
98		outChannel.close();
99		long end = System.currentTimeMillis();
100		System.out.println(end - start);
101	}
102	
103	@Test
104	public void test3() throws IOException {
105	//将数据从源通道传输到其他 Channel 中
106		//729
107		//684
108		//601
109		//706
110		//625
111		long start = System.currentTimeMillis();
112		FileChannel inChannel = FileChannel.open(Paths.get("E:\\BaiduYunDownload\\", "juc.zip"), StandardOpenOption.READ);
113		FileChannel outChannel = FileChannel.open(Paths.get("F:/", "juc-4.zip"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
114		//通道之间的数据传输
115		//inChannel.transferTo(0, inChannel.size(), outChannel);
116		outChannel.transferFrom(inChannel, 0, inChannel.size());
117		inChannel.close();
118		outChannel.close();
119		long end = System.currentTimeMillis();
120		System.out.println(end - start);
121	}
122	
123	@Test
124	public void test4() throws IOException {
125		RandomAccessFile randomAccessFile1 = new RandomAccessFile("E:/a.txt", "rw");
126		//获取通道
127		FileChannel fileChannel1 = randomAccessFile1.getChannel();
128		//分配指定大小的缓冲区
129		ByteBuffer buffer1 = ByteBuffer.allocate(100);
130		ByteBuffer buffer2 = ByteBuffer.allocate(1024);
131		//分散读取,从 Channel 中读取的数据“分散” 到多个 Buffer 中
132		ByteBuffer[] buffers = {buffer1, buffer2};
133		fileChannel1.read(buffers);
134		for (int i = 0; i < buffers.length; i++) {
135			buffers[i].flip();
136		}
137		System.out.println(new String(buffers[0].array(), 0, buffers[0].limit()));
138		System.out.println("-------------------");
139		System.out.println(new String(buffers[1].array(), 0, buffers[1].limit()));
140		//聚集写入,将多个 Buffer 中的数据“聚集”到 Channel
141		RandomAccessFile randomAccessFile2 = new RandomAccessFile("E:/b.txt", "rw");
142		FileChannel fileChannel2 = randomAccessFile2.getChannel();
143		fileChannel2.write(buffers);
144	}
145	
146	@Test
147	public void test5() {
148		/**
149		 * 编码：字符串->字节数组
150		 * 解码：字节数组->字符串
151		 */
152		//获取所有支持的字符集
153		SortedMap<String, Charset> availableCharsets = Charset.availableCharsets();
154		Set<Entry<String, Charset>> set = availableCharsets.entrySet();
155		for (Entry<String, Charset> entry: set) {
156			System.out.println(entry.getKey() + "--" + entry.getValue());
157		}
158	}
159	
160	@Test
161	public void test6() throws CharacterCodingException {
162		Charset charset = Charset.forName("GBK");
163		//编码器
164		CharsetEncoder charsetEncoder = charset.newEncoder();
165		//解码器
166		CharsetDecoder charsetDecoder = charset.newDecoder();
167		CharBuffer charBuffer = CharBuffer.allocate(1024);
168		charBuffer.put("你好");
169		charBuffer.flip();
170		//编码
171		ByteBuffer byteBuffer = charsetEncoder.encode(charBuffer);
172		
173		for (int i = 0; i < 4; i++) {
174			//字节数组
175			System.out.println(byteBuffer.get());
176		}
177		//切换到读模式
178		byteBuffer.flip();
179		//解码
180		CharBuffer charBuffer2 = charsetDecoder.decode(byteBuffer);
181		System.out.println(charBuffer2.toString());
182	}
183}
点赞
收藏

评论区

加载中...

相关推荐

MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1

文章目录问题用navicat导入数据时，报错：原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等，这样可以更容易地在不同的环境中使用MySQL。全局s

Oracle 分组与拼接字符串同时使用

SELECTT.,ROWNUMIDFROM(SELECTT.EMPLID,T.NAME,T.BU,T.REALDEPART,T.FORMATDATE,SUM(T.S0)S0,MAX(UPDATETIME)CREATETIME,LISTAGG(TOCHAR(

手写Java HashMap源码

HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22

Java NIO和IO的区别

IO               NIO面向流           面向缓冲阻塞IO           非阻塞IO无               选择器面向流与面向缓冲JavaNIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。JavaIO面向流意味着每次从流中

JAVA NIO(一)

1NIO概述1.1NIO(newIO)是一个可以替代javaIOAPI的API，NIO提供了与标准IO不同的工作方式，标准IO是基于字节流和字符流进行操作的，而NIO是基于channel和Buffer进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写到通道中,方式如例图示，JAVANIO的几个核心组成部分是channels，Buf

JAVA NIO入门（一）

一、JAVANIO概念　　JAVANIO是从JDK1.4就开始有的，之前只用过IO流，其实NIO和IO一样都是可以用来读取或者写入文件，只不过原来的IO是面向流进行操作的，而NIO是面向缓冲区进行操作二、通过一个小例子初步了解下NIO如何进行文件读写　!(https://oscimg.oschina.net/oscnet/