[关闭]
@huangyichun 2017-08-30T07:56:22.000000Z 字数 7503 阅读 1056

Java NIO

I/O

image.png-69.4kB
原来I/O是单向的，面向流的
NIO是双向的
image.png-38.7kB
image.png-148.4kB

image.png-48.7kB
image.png-136.4kB
image.png-100.2kB
image.png-110.6kB

  1.     import org.junit.Test;
  3.     import java.nio.ByteBuffer;
  5.     /**
  6.      * 一、 缓冲区(buffer):在Java NIO中负责数据的存取，缓冲区就是数组，用于存储不同数据类型的数据
  7.      *
  8.      * 根据数据类型不同（boolean除外），提供了相应类型的缓冲区:
  9.      * ByteBuffer
  10.      * CharBuffer
  11.      * ShortBuffer
  12.      * IntBuffer
  13.      * LongBuffer
  14.      * FloatBuffer
  15.      * DoubleBuffer
  16.      *
  17.      * 上述缓存区的管理几乎一致，通过allocate()获取缓冲区
  18.      *
  19.      * 二、缓存区存取数据的两个核心方法
  20.      * put()：存入数据到缓冲区中
  21.      * get(): 获取缓冲区中的数据
  22.      *
  23.      * 三、缓冲区中的四个核心属性
  24.      *
  25.      * private int mark = -1;标记：表示记录当前position的位置。可以通过reset()恢复mark位置
  26.      * private int position = 0; 位置:表示缓冲区中正在操作数据的位置
  27.      * private int limit;   界限：表示缓存区中可以操作数据的大小(limit)后面的数据不能进行读写
  28.      * private int capacity; 容量:表示缓存区中最大存储数据容量，一旦声明不能改变
  29.      *
  30.      * 0 <= mark <= position <= limit <= capacity
  31.      *
  32.      * 四、直接缓冲区与非直接缓冲区
  33.      * 非直接缓冲区:通过allocate()方法分配缓冲区，将缓冲区建立在JVM的内存中
  34.      * 直接缓冲区:通过allocateDirect()方法分配直接缓冲区，将缓冲区建立在物理内存中，可以提高效率
  35.      */
  36.     public class TestBuffer {
  38.         @Test
  39.         public void test3(){
  40.             //直接缓冲区
  41.             ByteBuffer buf = ByteBuffer.allocateDirect(1024);
  42.             System.out.println(buf.isDirect());
  43.         }
  46.         @Test
  47.         public void test2(){
  49.             String str = "abcde";
  50.             ByteBuffer buf = ByteBuffer.allocate(1024);
  51.             buf.put(str.getBytes());
  53.             buf.flip();
  55.             byte[] dst = new byte[buf.limit()];
  56.             buf.get(dst, 0 ,2);//读取两个
  57.             System.out.println(new String(dst,0,2));
  58.             System.out.println("position: "+buf.position());
  60.             //mark()标记
  61.             buf.mark();
  62.             buf.get(dst, 2, 2);
  63.             System.out.println(new String(dst, 0, 4));
  64.             System.out.println("position: "+buf.position());
  66.             buf.reset();
  67.             System.out.println("position: "+buf.position());
  69.             if(buf.hasRemaining()){//判断缓冲区是否还有剩余的
  70.                 System.out.println(buf.remaining());
  71.             }
  72.         }
  74.         @Test
  75.         public void test1() {
  76.             String str = "abcde";
  77.             //1.分配一个指定大小的缓存区
  78.             ByteBuffer buf = ByteBuffer.allocate(1024);
  79.             System.out.println("------------allocate----------------");
  80.             System.out.println("position: "+buf.position());
  81.             System.out.println("limit: " + buf.limit());
  82.             System.out.println("capacity: " + buf.capacity());
  84.             System.out.println("----------------put()------------");
  85.             //2.利用put()方法存入数据到缓冲区中——写数据模式
  86.             buf.put(str.getBytes());
  87.             System.out.println("position: "+buf.position());
  88.             System.out.println("limit: " + buf.limit());
  89.             System.out.println("capacity: " + buf.capacity());
  91.             System.out.println("----------------flip()------------");
  93.             //3.切换成读取数据模式
  94.             buf.flip();
  95.             System.out.println("position: "+buf.position());
  96.             System.out.println("limit: " + buf.limit());
  97.             System.out.println("capacity: " + buf.capacity());
  99.             System.out.println("----------------get()------------");
  100.             //4利用get()方法读取缓冲区的数据
  101.             byte[] dst = new byte[buf.limit()];
  102.             buf.get(dst);
  103.             System.out.println(new String(dst, 0, dst.length));
  104.             System.out.println("position: "+buf.position());
  105.             System.out.println("limit: " + buf.limit());
  106.             System.out.println("capacity: " + buf.capacity());
  108.             System.out.println("----------------rewind()------------");
  109.             //5.rewind() 可重复读数据
  110.             buf.rewind();
  111.             System.out.println("position: "+buf.position());
  112.             System.out.println("limit: " + buf.limit());
  113.             System.out.println("capacity: " + buf.capacity());
  115.             System.out.println("----------------clear()------------");
  116.             //6.clear():清空缓冲区,但是缓冲区中的数据依然存在，但是出于"被遗忘"状态
  117.             buf.clear();
  118.             System.out.println("position: "+buf.position());
  119.             System.out.println("limit: " + buf.limit());
  120.             System.out.println("capacity: " + buf.capacity());
  122.             System.out.println((char)buf.get(1));
  123.         }
  126.     }

通道

image.png-96.8kB

  1.     import org.junit.Test;
  3.     import java.io.*;
  4.     import java.nio.ByteBuffer;
  5.     import java.nio.CharBuffer;
  6.     import java.nio.MappedByteBuffer;
  7.     import java.nio.channels.FileChannel;
  8.     import java.nio.channels.FileChannel.MapMode;
  9.     import java.nio.charset.CharacterCodingException;
  10.     import java.nio.charset.Charset;
  11.     import java.nio.charset.CharsetDecoder;
  12.     import java.nio.charset.CharsetEncoder;
  13.     import java.nio.file.Paths;
  14.     import java.nio.file.StandardOpenOption;
  15.     import java.util.Arrays;
  16.     import java.util.Map;
  17.     import java.util.stream.Stream;
  19.     /**
  20.      * 一、通道(Channel):用于源节点与目标节点的链接。在Java NIO中负责缓冲区中数据的传输
  21.      * Channel本身不存储数据，因此需要配合缓冲区进行传输。
  22.      * <p>
  23.      * 二、通道的主要实现类
  24.      * java.nio.channels.Channel接口:
  25.      * |--FileChannel
  26.      * |--SocketChannel
  27.      * |--ServerSocketChannel
  28.      * |--DatagramChannel
  29.      * 三、获取通道
  30.      * 1. Java支持通道的类提供了getChannel()方法
  31.      * 本地IO:
  32.      * FileInputStream/FileOutputStream
  33.      * RandomAccessFile
  34.      * <p>
  35.      * 网络IO:
  36.      * Socket
  37.      * ServerSocket
  38.      * DatagramSocket
  39.      * 2. 在JDK 1.7中的NIO.2针对各个通道提供了静态方法open()
  40.      * 3. 在JDK 1.7中的NIO.2的Files工具类的newByteChannel()
  41.      *
  42.      * 四、通道之间的数据传输
  43.      * transferFrom()
  44.      * transferTo()
  45.      *
  46.      * 五、分散(Scatter）与聚集(Gather)
  47.      * 分散读取(Scattering Reads):将通道中的数据分散到多个缓冲区中
  48.      * 聚集写入(Gathering Writers):将多个缓冲区中的数据聚集到通道中
  49.      *
  50.      * 六、字符集：Charset
  51.      * 编码:  字符串——>字节数组
  52.      * 解码:  字节数组——>字符串
  53.      *
  54.      */
  55.     public class TestChannel {
  57.         //字符集
  58.         @Test
  59.         public void test7() throws CharacterCodingException {
  60.             Charset cs1 = Charset.forName("GBK");
  61.             //获取编码器
  62.             CharsetEncoder ce = cs1.newEncoder();
  63.             //获取解码器
  64.             CharsetDecoder cd = cs1.newDecoder();
  65.             CharBuffer cBuf = CharBuffer.allocate(1024);
  66.             cBuf.put("尚硅谷威武！");
  67.             cBuf.flip();//切换读
  69.             //编码
  70.             ByteBuffer byteBuffer = ce.encode(cBuf);
  72.            for(int i=0; i<cBuf.limit()*2; i++){
  73.                System.out.println(byteBuffer.get());
  74.            }
  76.            //解码
  77.             byteBuffer.flip();
  78.             CharBuffer cBuf2 = cd.decode(byteBuffer);
  79.             System.out.println(cBuf2.toString());
  81.         }
  82.         @Test
  83.         public void test6(){
  84.             Map<String, Charset> map =  Charset.availableCharsets();
  85.             map.forEach((x,y)->{
  86.                 System.out.println(x+"="+y);
  87.             });
  88.         }
  90.         //分散和聚集
  91.         @Test
  92.         public void test5() throws IOException {
  93.             RandomAccessFile raf = new RandomAccessFile("学习清单.txt","rw");
  95.             //1.获取通道
  96.             FileChannel channel = raf.getChannel();
  97.             //2.分配指定大小的缓冲区
  98.             ByteBuffer buf1 = ByteBuffer.allocate(100);
  99.             ByteBuffer buf2 = ByteBuffer.allocate(1024);
  101.             //3.分散读取
  102.             ByteBuffer[] bufs = {buf1, buf2};
  103.             channel.read(bufs);
  105.             Arrays.stream(bufs).forEach(ByteBuffer::flip);//转换成读模式
  106.             System.out.println(new String(bufs[0].array(),0, bufs[0].limit()));
  107.             System.out.println("------------------------");
  108.             System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
  110.             //4.聚集写入
  111.             RandomAccessFile raf2 = new RandomAccessFile("2.txt","rw");
  112.             FileChannel channel2 = raf2.getChannel();
  114.             channel2.write(bufs);
  116.             channel.close();
  117.             channel2.close();
  119.         }
  121.         //通道之间的数据传输(直接缓冲区,内存映射文件)
  122.         @Test
  123.         public void test4() throws IOException {
  125.             FileChannel inChannel = FileChannel.open(Paths.get("E:/1.zip"),StandardOpenOption.READ);
  126.             FileChannel outChannel = FileChannel.open(Paths.get("E:/2.zip"),StandardOpenOption.READ, StandardOpenOption.WRITE,StandardOpenOption.CREATE);
  128.     //        inChannel.transferTo(0, inChannel.size(), outChannel);
  129.             outChannel.transferFrom(inChannel, 0, inChannel.size());
  130.             inChannel.close();
  131.             outChannel.close();
  132.         }
  134.         //3. I/O操作
  135.         @Test
  136.         public void test3() throws IOException {    //9755
  137.             long start = System.currentTimeMillis();
  138.             FileInputStream fis = new FileInputStream("E:/1.zip");
  139.             FileOutputStream fos = new FileOutputStream("E:/2.zip");
  140.             BufferedInputStream bufis = new BufferedInputStream(fis);
  141.             byte[] bts = new byte[1024];
  142.             while(bufis.read(bts) != -1){
  143.                 fos.write(bts);
  144.             }
  145.             bufis.close();
  146.             fis.close();
  147.             fos.close();
  149.             long end = System.currentTimeMillis();
  150.             System.out.println("耗费时间为:" + (end-start));
  151.         }
  153.         //2.使用直接缓冲区完成文件复制(内存映射文件)
  154.         @Test
  155.         public void test2() throws IOException {//2457
  156.             long start = System.currentTimeMillis();
  158.             FileChannel inChannel = FileChannel.open(Paths.get("E:/1.zip"), StandardOpenOption.READ);
  159.             FileChannel outChannel = FileChannel.open(Paths.get("E:/2.zip"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
  160.             //内存映射文件
  161.             MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
  162.             MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
  164.             //直接对缓冲区对数据的读写操作
  165.             byte[] dst = new byte[inMappedBuf.limit()];
  166.             inMappedBuf.get(dst);
  167.             outMappedBuf.put(dst);
  169.             inChannel.close();
  170.             outChannel.close();
  172.             long end = System.currentTimeMillis();
  173.             System.out.println("耗费时间为:" + (end-start));
  174.         }
  176.         //1.利用通道完成文件的复制(非直接缓冲区)
  177.         @Test
  178.         public void test1() throws IOException {//9942
  179.             long start = System.currentTimeMillis();
  180.             FileInputStream fis = new FileInputStream("E:/1.zip");
  181.             FileOutputStream fos = new FileOutputStream("E:/2.zip");
  183.             //获取通道
  184.             FileChannel inChannel = fis.getChannel();
  185.             FileChannel outChannel = fos.getChannel();
  187.             //分配指定大小的缓存区
  188.             ByteBuffer buf = ByteBuffer.allocate(1024);
  190.             //将通道中的数据存入缓冲区中
  191.             while (inChannel.read(buf) != -1) {
  192.                 //将缓冲区中的数据写入通道中
  193.                 buf.flip(); //切换成读取数据的模式
  194.                 outChannel.write(buf);
  195.                 buf.clear();//清空缓冲区
  196.             }
  198.             outChannel.close();
  199.             inChannel.close();
  200.             fos.close();
  201.             fis.close();
  203.             long end = System.currentTimeMillis();
  204.             System.out.println("耗费时间为:" + (end-start));
  205.         }
  206.     }

NIO非阻塞式网络编程

image.png-60.6kB

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注