下载工具
主题壁纸
其它软件
办公软件
压缩刻录
图形图象
安全杀毒
手机数码
操作系统
教育学习
浏览器
游戏娱乐
系统工具
编程开发
网络应用
聊天工具
股票网银
视频软件
输入法
阅读翻译
音乐软件
下载工具专用下载器
下载工具通用下载器
其它软件出行查询
其它软件天文地理
其它软件日历闹钟
其它软件电子账本
办公软件PDF转换
办公软件办公常用
办公软件文档处理
办公软件记事管理
办公软件邮件
压缩刻录光盘刻录
压缩刻录压缩工具
压缩刻录虚拟光驱
图形图象CAD图形
图形图象图象处理
图形图象截图软件
图形图象看图软件
手机数码刷机工具
手机数码手机模拟器
手机数码数码转换
手机数码苹果工具
操作系统手机
操作系统电脑
操作系统手机Android
操作系统手机IOS
操作系统电脑LINUX
操作系统电脑MacOS
操作系统电脑UNIX
操作系统电脑Windows
教育学习外语工具
教育学习幼儿教育
教育学习电子书籍
教育学习考试练习
浏览器双核浏览器
浏览器游戏浏览器
浏览器高速浏览器
游戏娱乐休闲益智
游戏娱乐游戏平台
游戏娱乐游戏辅助
系统工具WIN自带工具
系统工具备份还原
系统工具桌面工具
系统工具硬件检测
系统工具系统优化
系统工具驱动工具
编程开发安卓开发
编程开发开发平台
编程开发辅助工具
编程开发运行库
网络应用上传下载
网络应用上网工具
网络应用云存储
网络应用网络加速
网络应用远程工具
聊天工具游戏语音
聊天工具社交聊天
聊天工具网络电话
聊天工具视频聊天
股票网银网银软件
股票网银股票交易
股票网银股票行情
视频软件字幕制作
视频软件本地播放
视频软件格式转换
视频软件网络视频
视频软件视频编辑
阅读翻译PDF阅读器
阅读翻译小说阅读器
阅读翻译翻译词典
音乐软件K歌软件
音乐软件在线音乐
音乐软件网络电台
音乐软件音频处理

  1 package com.nio.test;
  2 
  3 import java.io.IOException;
  4 import java.io.RandomAccessFile;
  5 import java.net.InetSocketAddress;
  6 import java.nio.ByteBuffer;
  7 import java.nio.CharBuffer;
  8 import java.nio.channels.DatagramChannel;
  9 import java.nio.channels.FileChannel;
 10 import java.nio.channels.Pipe;
 11 import java.nio.channels.ServerSocketChannel;
 12 import java.nio.channels.SocketChannel;
 13 import java.nio.charset.Charset;
 14 import java.nio.charset.CharsetDecoder;
 15 import java.nio.charset.CoderResult;
 16 import java.nio.file.Files;
 17 import java.nio.file.LinkOption;
 18 import java.nio.file.Path;
 19 import java.nio.file.Paths;
 20 
 21 public class ChannelTest {
 22     public static void main(String[] args) throws Exception {
 23         new ChannelTest().filewrite();
 24         new ChannelTest().byteBufferUtf8();
 25         new ChannelTest().fileread();
 26         new ChannelTest().clientsocket();
 27         new ChannelTest().serverSocket();
 28         new ChannelTest().serverDatagram();
 29         new ChannelTest().clientDatagram();
 30         new ChannelTest().pipe();
 31         new ChannelTest().NIOPath();
 32     }
 33 
 34     private void fileread() {
 35         RandomAccessFile aFile;
 36         Charset charset = Charset.forName("UTF-8");
 37         CharsetDecoder decoder = charset.newDecoder();
 38         try {
 39             // 在使用FileChannel之前，必须先打开它。但是，我们无法直接打开一个FileChannel，
 40             // 需要通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例
 41             aFile = new RandomAccessFile("src/com/nio/test/nio-data.txt", "rw");
 42 
 43             FileChannel inChannel = aFile.getChannel();
 44             // 首先，分配一个Buffer。从FileChannel中读取的数据将被读到Buffer中。
 45             // create buffer with capacity of 48 byte
 46             ByteBuffer byteBuffer = ByteBuffer.allocate(48);// read into buffer.
 47             CharBuffer charBuffer = CharBuffer.allocate(48);
 48 
 49             // 调用多个read()方法之一 从FileChannel中读取数据。
 50             int bytesRead = inChannel.read(byteBuffer);
 51 
 52             char[] tmp = null; // 临时存放转码后的字符
 53             byte[] remainByte = null;// 存放decode操作后未处理完的字节。decode仅仅转码尽可能多的字节，此次转码不了的字节需要缓存，下次再转
 54             int leftNum = 0; // 未转码的字节数
 55             
 56             while (bytesRead != -1) {
 57 
 58                 //System.out.println("Read " + bytesRead);
 59                 byteBuffer.flip(); // make buffer ready for read
 60                 decoder.decode(byteBuffer, charBuffer, false);
 61                 
 62                 charBuffer.flip();
 63 
 64                 remainByte = null;
 65                 leftNum = byteBuffer.limit() - byteBuffer.position();
 66                 if (leftNum > 0) { // 记录未转换完的字节
 67                     remainByte = new byte[leftNum];
 68                     byteBuffer.get(remainByte, 0, leftNum);
 69                 }
 70                 
 71                 // 输出已转换的字符
 72                 tmp = new char[charBuffer.length()];
 73                 while (charBuffer.hasRemaining()) {
 74                     charBuffer.get(tmp);
 75                     System.out.print(new String(tmp));
 76                 }
 77                 
 78                 byteBuffer.clear(); // make buffer ready for writing
 79                 charBuffer.clear();
 80 
 81                 if (remainByte != null) {
 82                     byteBuffer.put(remainByte); // 将未转换完的字节写入bBuf，与下次读取的byte一起转换
 83                 }
 84                 
 85                 bytesRead = inChannel.read(byteBuffer);
 86             }
 87             
 88             aFile.close();
 89         } catch (Exception e) {
 90             // TODO Auto-generated catch block
 91             e.printStackTrace();
 92         }
 93     }
 94 
 95     private void filewrite() throws Exception {
 96         RandomAccessFile accessFile = new RandomAccessFile("src/com/nio/test/nio-data11.txt", "rw");
 97         FileChannel fileChannel = accessFile.getChannel();
 98         String newDate = "New String to write to file" + System.currentTimeMillis();
 99         ByteBuffer buffer = ByteBuffer.allocate(48);
100         buffer.clear();
101         buffer.put(newDate.getBytes());
102         buffer.flip();
103         while (buffer.hasRemaining()) {
104             fileChannel.write(buffer);
105         }
106 
107         /**
108          * FileChannel的truncate方法
109          * 可以使用FileChannel.truncate()方法截取一个文件。截取文件时，文件将中指定长度后面的部分将被删除。如：
110          * 
111          * 1 channel.truncate(1024); 这个例子截取文件的前1024个字节。
112          */
113         //fileChannel.truncate(12);
114         /**
115          * FileChannel.force()方法将通道里尚未写入磁盘的数据制写到磁盘上。出于性能方面的考虑，操作系统会将数据缓存在内存中，
116          * 所以无法保证写入到FileChannel里的数据一定会即时写到磁盘上。要保证这一点，需要调用force()方法。
117          */
118         fileChannel.force(true);// force()方法有一个boolean类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。
119 
120         fileChannel.close();
121     }
122 
123     private void clientsocket() throws Exception {
124         SocketChannel socketChannel = SocketChannel.open();
125         //可以设置 SocketChannel 为非阻塞模式（non-blocking mode）.设置之后，就可以在异步模式下调用connect(), read() 和write()了。
126         socketChannel.configureBlocking(false);
127         socketChannel.connect(new InetSocketAddress("127.0.0.1", 60000));
128         
129         //为非阻塞模式的判断用
130         while(!socketChannel.finishConnect()){
131             socketChannelRead(socketChannel);
132         }
133     }
134     
135     /**
136      * 
137      * ServerSocketChannel
138      * 
139      * Java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 
140      * 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。
141      * 
142      * @throws Exception 
143      * 
144      */
145     private void serverSocket() throws Exception {
146         // 通过调用 ServerSocketChannel.open() 方法来打开ServerSocketChannel.
147         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
148         serverSocketChannel.socket().bind(new InetSocketAddress(60000));
149         // ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept()
150         // 方法会立刻返回，如果还没有新进来的连接,返回的将是null。
151         // 因此，需要检查返回的SocketChannel是否是null.
152         serverSocketChannel.configureBlocking(false);
153         // 通常不会仅仅只监听一个连接,在while循环中调用 accept()方法.
154         while (true) {
155             // 监听新进来的连接
156             // 通过 ServerSocketChannel.accept() 方法监听新进来的连接。当
157             // accept()方法返回的时候,它返回一个包含新进来的连接的 SocketChannel。
158             // 因此, accept()方法会一直阻塞到有新连接到达。
159             SocketChannel socketChannel = serverSocketChannel.accept();
160 
161             // 非阻塞模式
162             if (socketChannel != null) {
163                 socketChannelRead(socketChannel);
164             }
165             //通过调用ServerSocketChannel.close() 方法来关闭ServerSocketChannel
166             // serverSocketChannel.close();
167         }
168     }
169     
170     private static StringBuilder socketChannelRead(SocketChannel socketChannel) throws Exception {
171         
172         StringBuilder sb = new StringBuilder();
173         
174         Charset charset = Charset.forName("GBK");
175         CharsetDecoder decoder = charset.newDecoder();
176 
177         ByteBuffer byteBuffer = ByteBuffer.allocate(10);
178         CharBuffer charBuffer = CharBuffer.allocate(10);
179 
180         int bytesRead = socketChannel.read(byteBuffer);
181 
182         char[] tmp = null; // 临时存放转码后的字符
183         byte[] remainByte = null;// 存放decode操作后未处理完的字节。decode仅仅转码尽可能多的字节，此次转码不了的字节需要缓存，下次再转
184         int leftNum = 0; // 未转码的字节数
185 
186         while (bytesRead != -1) {
187 
188             // System.out.println("Read " + bytesRead);
189             byteBuffer.flip(); // make buffer ready for read
190             CoderResult result = decoder.decode(byteBuffer, charBuffer, false);
191 //            System.out.println("result:"+ result);
192             charBuffer.flip();
193 
194             remainByte = null;
195             leftNum = byteBuffer.limit() - byteBuffer.position();
196             if (leftNum > 0) { // 记录未转换完的字节
197                 remainByte = new byte[leftNum];
198                 byteBuffer.get(remainByte, 0, leftNum);
199             }
200 
201             // 输出已转换的字符
202             tmp = new char[charBuffer.length()];
203             while (charBuffer.hasRemaining()) {
204                 charBuffer.get(tmp);
205                 //sb.append(tmp);
206                 System.out.print(new String(tmp));
207             }
208 
209             byteBuffer.clear(); // make buffer ready for writing
210             charBuffer.clear();
211 
212             if (remainByte != null) {
213                 byteBuffer.put(remainByte); // 将未转换完的字节写入bBuf，与下次读取的byte一起转换
214             }
215             bytesRead = socketChannel.read(byteBuffer);
216         }
217         return sb;
218     }
219     
220     /**
221      * Java NIO中的DatagramChannel是一个能收发UDP包的通道。
222      * 因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。
223      * 
224      * @throws Exception
225      */
226     private void serverDatagram() throws Exception {
227         /**
228          * 这个例子打开的 DatagramChannel可以在UDP端口9999上接收数据包。
229          */
230         DatagramChannel channel = DatagramChannel.open();
231         channel.socket().bind(new InetSocketAddress(60000));
232         
233         Charset charset = Charset.forName("GBK");
234         CharsetDecoder decoder = charset.newDecoder();
235         
236         //通过receive()方法从DatagramChannel接收数据
237         //receive()方法会将接收到的数据包内容复制到指定的Buffer.
238         //如果Buffer容不下收到的数据，多出的数据将被丢弃。
239         ByteBuffer byteBuffer = ByteBuffer.allocate(48);
240         CharBuffer charBuffer = CharBuffer.allocate(48);
241         byteBuffer.clear();
242         channel.receive(byteBuffer);
243         
244         char[] tmp = null; // 临时存放转码后的字符
245         while(true){
246             byteBuffer.flip();
247             
248             CoderResult result = decoder.decode(byteBuffer, charBuffer, false);
249             
250             charBuffer.flip();
251             tmp = new char[charBuffer.length()];
252             while (charBuffer.hasRemaining()) {
253                 charBuffer.get(tmp);
254                 System.out.print(new String(tmp));
255             }
256             byteBuffer.clear();
257             charBuffer.clear();
258             channel.receive(byteBuffer);
259         }
260     }
261     /**
262      * 可以将DatagramChannel“连接”到网络中的特定地址的。由于UDP是无连接的，
263      * 连接到特定地址并不会像TCP通道那样创建一个真正的连接。
264      * 而是锁住DatagramChannel ，让其只能从特定地址收发数据。
265      * 当连接后，也可以使用read()和write()方法，就像在用传统的通道一样。只是在数据传送方面没有任何保证。
266      * 
267      * @throws Exception
268      */
269     private void clientDatagram() throws Exception {
270         DatagramChannel channel = DatagramChannel.open();
271         String newData = "New^啊&ng& to write to fasdfsdafsdfdsfsadf1JLKJL)(&)&*(&&ile..." + System.currentTimeMillis();
272         ByteBuffer buf = ByteBuffer.allocate(480);
273         buf.clear();
274         buf.put(newData.getBytes("GBK"));
275         buf.flip();
276         
277         //通过send()方法从DatagramChannel发送数据  即使下面的地址无法连接也是可以发送数据的。
278         int bytesSent = channel.send(buf, new InetSocketAddress("127.0.0.1", 60000));
279         //UDP在数据传送方面没有任何保证。
280     }
281     
282     /**
283      * Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。
284      * 数据会被写到sink通道，从source通道读取。
285      * @throws Exception 
286      */
287     private void pipe() throws Exception {
288         
289         Pipe pipe = Pipe.open();
290 
291         //构建一条线程 ,获取管道的SinkChannel，用于数据录入
292         Thread thread = new Thread(() -> {
293             // 向管道写数据
294             // 要向管道写数据，需要访问sink通道。
295             // 通过调用SinkChannel的write()方法，将数据写入SinkChannel,像这样：
296             Pipe.SinkChannel sinkChannel = pipe.sink();
297             String newData = "New String to write to file..." + System.currentTimeMillis();
298             ByteBuffer buf = ByteBuffer.allocate(48);
299             buf.clear();
300             try {
301                 buf.put(newData.getBytes("GBK"));
302 
303                 buf.flip();
304                 while (buf.hasRemaining()) {
305                     sinkChannel.write(buf);
306                 }
307             } catch (Exception e) {
308                 // TODO Auto-generated catch block
309                 e.printStackTrace();
310             }
311         });
312         
313         //构建一条线程 ,让其去获取到SinkChannel录入的数据并输出
314         Thread thread1 = new Thread(() -> {
315             // 从管道读取数据
316             // 从读取管道的数据，需要访问source通道，
317             // 调用source通道的read()方法来读取数据，
318             Pipe.SourceChannel sourceChannel = pipe.source();
319 
320             Charset charset = Charset.forName("GBK");
321             CharsetDecoder decoder = charset.newDecoder();
322 
323             ByteBuffer byteBuffer = ByteBuffer.allocate(48);
324             CharBuffer charBuffer = CharBuffer.allocate(48);
325 
326             char[] tmp = null; // 临时存放转码后的字符
327             byte[] remainByte = null;// 存放decode操作后未处理完的字节。decode仅仅转码尽可能多的字节，此次转码不了的字节需要缓存，下次再转
328             int leftNum = 0; // 未转码的字节数
329 
330             // read()方法返回的int值会告诉我们多少字节被读进了缓冲区。
331             int bytesRead;
332             try {
333                 bytesRead = sourceChannel.read(byteBuffer);
334 
335                 while (bytesRead != -1) {
336 
337                     // System.out.println("Read " + bytesRead);
338                     byteBuffer.flip(); // make buffer ready for read
339                     CoderResult result = decoder.decode(byteBuffer, charBuffer, false);
340                     // System.out.println("result:"+ result);
341                     charBuffer.flip();
342 
343                     remainByte = null;
344                     leftNum = byteBuffer.limit() - byteBuffer.position();
345                     if (leftNum > 0) { // 记录未转换完的字节
346                         remainByte = new byte[leftNum];
347                         byteBuffer.get(remainByte, 0, leftNum);
348                     }
349 
350                     // 输出已转换的字符
351                     tmp = new char[charBuffer.length()];
352                     while (charBuffer.hasRemaining()) {
353                         charBuffer.get(tmp);
354                         // sb.append(tmp);
355                         System.out.print(new String(tmp));
356                     }
357 
358                     byteBuffer.clear(); // make buffer ready for writing
359                     charBuffer.clear();
360 
361                     if (remainByte != null) {
362                         byteBuffer.put(remainByte); // 将未转换完的字节写入bBuf，与下次读取的byte一起转换
363                     }
364                     bytesRead = sourceChannel.read(byteBuffer);
365                 }
366             } catch (IOException e) {
367                 // TODO Auto-generated catch block
368                 e.printStackTrace();
369             }
370         });
371         
372         thread.run();
373         Thread.sleep(2000L);
374         thread1.run();
375         
376     }
377     
378     /**
379      * Path接口是java NIO2的一部分。首次在java 7中引入。Path接口在java.nio.file包下，
380      * 所以全称是java.nio.file.Path。 java中的Path表示文件系统的路径。可以指向文件或文件夹。
381      * 也有相对路径和绝对路径之分。绝对路径表示从文件系统的根路径到文件或是文件夹的路径。
382      * 相对路径表示从特定路径下访问指定文件或文件夹的路径。相对路径的概念可能有点迷糊,可以自己百度一下。
383      * 不要将文件系统的path和操作系统的环境变量path搞混淆。java.nio.file.Path接口和操作系统的path环境变量没有任何关系。
384      * 在很多方面，java.nio.file.Path接口和java.io.File有相似性，但也有一些细微的差别。
385      * 在很多情况下，可以用Path来代替File类。
386      */
387     private void NIOPath() {
388         //为了使用java.nio.file.Path实例，必须首先创建它。可以使用Paths 类的静态方法Paths.get()来产生一个实例。
389         //请注意例子开头的两个import语句。想要使用Paths类和Path接口，必须首先引入相应包。
390         //其次，注意Paths.get(“c:\data\myfile.txt”)的用法。
391         //其使用了Paths.get方法创建了Path的实例。它是一个工厂方法。
392         Path path = Paths.get("c:\data\myfile.txt");//绝对路径Path
393         
394         
395         //创建相对路径Path
396         //java NIO Path类也能使用相对路径。可以通过Paths.get(basePath, relativePath)创建一个相对路径Path。
397         Path projects = Paths.get("d:\data", "projects");
398         //创建了一个指向d:dataprojects文件夹的实例。
399         Path file = Paths.get("d:\data", "projects\a-project\myfile.txt");
400         //创建了一个指向 d:dataprojectsa-projectmyfile.txt 文件的实例。
401         //.表示当前路径。例如，如果以如下方式创建一个相对路径：
402         //创建的Path实例对应的路径就是运行这段代码的项目工程目录。
403         Path currentDir = Paths.get(".");
404         System.out.println(currentDir.toAbsolutePath());
405         //..表示父类目录。
406         Path parentDir = Paths.get("..");
407         String path1 = "d:\data\projects\a-project\..\another-project";
408         Path parentDir2 = Paths.get(path1);
409         //d:dataprojectsanother-project在a-project目录后面的..符号，
410         //将指向的目录修改为projects目录，因此，最终path指向another-project目录。
411         
412         
413         //Path 的normalize()方法可以标准化路径。
414         String originalPath =
415                  "d:\data\projects\a-project\..\another-project";
416 
417         Path path3 = Paths.get(originalPath);
418         System.out.println("path3 = " + path3);
419 
420         Path path2 = path3.normalize();
421         System.out.println("path2 = " + path2);
422         //如你所见，标准化后的路径不再包含 a-project..部分，因为它是多余的。
423         
424         //Files.exists()
425         //Files.exists()方法用来检查文件系统中是否存在某路径。
426         //Path实例对应的路径可能在文件系统中并不存在。例如，如果打算新建一个文件夹，首先需要创建一个对应的Path实例，然后才能创建对应路径下的文件夹。
427         //因为Path实例对应的路径在文件系统的存在性不确定，可以使用Files.exists()方法确认Path对应的路径是否存在 (也就是开发需要自己显式的去调用该方法确认)。
428         //如下是Files.exists()的示例：
429         Path path5 = Paths.get("data/logging.properties");
430 
431         boolean pathExists = Files.exists(path, new LinkOption[] { LinkOption.NOFOLLOW_LINKS });
432         System.out.println(pathExists);
433         //示例中首先创建了一个Path。然后，通过调用Files.exists方法并将path作为第一个参数确认path对应的路径是否存在。
434         //注意下Files.exist()方法的第二个参数。第二个参数数组是评判路径是否存在时使用的规则。
435         //示例中，数组包含LinkOption.NOFOLLOW_LINKS枚举类型，表示Files.exists不会跟进到路径中有连接的下层文件目录。
436         //表示path路径中如果有连接，Files.exists方法不会跟进到连接中去
437     }
438     
439     private void byteBufferUtf8() throws Exception {
440         Charset charset = null;
441         CharsetDecoder decoder = null;
442         String charsetName = "UTF-8";
443         int capacity = 10;
444 
445         charset = Charset.forName(charsetName);
446         decoder = charset.newDecoder();
447 
448         String s = "客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都";
449         byte[] bytes = s.getBytes(charsetName);
450 
451         // 模拟接收的ByteBuffer size 10
452         ByteBuffer byteBuffer = ByteBuffer.allocate(capacity);
453         // 用于临时存放Bytebuffer转换后的字符
454         CharBuffer charBuffer = CharBuffer.allocate(capacity);
455         // 用于连接展示字符串
456         StringBuilder sb = new StringBuilder();
457 
458         int i = 0;
459         while (true) {
460             byteBuffer.put(bytes[i]);
461             i++;
462             if (byteBuffer.remaining() == 0 || i == bytes.length) {
463                 byteBuffer.flip();
464                 CoderResult coderResult;
465                 if (i != bytes.length) {
466                     coderResult = decoder.decode(byteBuffer, charBuffer, false);
467                 } else {
468                     coderResult = decoder.decode(byteBuffer, charBuffer, true);
469                 }
470                 // 有错误
471                 if (coderResult.isError()) {
472                     coderResult.throwException();
473                 }
474                 charBuffer.flip();
475                 sb.append(charBuffer);
476                 charBuffer.clear();
477                 byteBuffer.compact();
478             }
479             // 退出循环
480             if (i == bytes.length) {
481                 break;
482             }
483         }
484         System.out.println(sb);
485     }
486 }