int bytesWritten = inChannel.write(buf);

int bytesRead = inChannel.read(buf);

String str = "Siline";
//创建一个输出流->channel
FileOutputStream fileOutputStream = new FileOutputStream("file01.txt");

//通过 fileOutputStream 获取 对应的 FileChannel(即fileOutputStream内置了FileChannel)
//这个 fileChannel 真实类型是  FileChannelImpl
FileChannel fileChannel = fileOutputStream.getChannel();

//创建一个缓冲区 ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

//将 str 放入 byteBuffer
byteBuffer.put(str.getBytes());

//写->读，需要对byteBuffer 进行flip 
byteBuffer.flip();

//将byteBuffer 数据写入到 fileChannel
fileChannel.write(byteBuffer);
fileOutputStream.close();

//创建文件的输入流
File file = new File("file01.txt");
FileInputStream fileInputStream = new FileInputStream(file);

//通过fileInputStream 获取对应的FileChannel -> 实际类型  FileChannelImpl
FileChannel fileChannel = fileInputStream.getChannel();

//创建缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());

//将 通道的数据读入到Buffer
fileChannel.read(byteBuffer);

//将byteBuffer 的 字节数据 转成String
System.out.println(new String(byteBuffer.array()));
fileInputStream.close();

FileInputStream fileInputStream = new FileInputStream("1.txt");
FileChannel fileChannel01 = fileInputStream.getChannel();

FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
FileChannel fileChannel02 = fileOutputStream.getChannel();

ByteBuffer byteBuffer = ByteBuffer.allocate(512);

while (true) { //循环读取

  //这里有一个重要的操作，一定不要忘了
  byteBuffer.clear(); //清空buffer,重制标志位
  int read = fileChannel01.read(byteBuffer);
  System.out.println("read =" + read);
  if(read == -1) { //表示读完
    break;
  }
  //将buffer 中的数据写入到 fileChannel02 -- 2.txt
  byteBuffer.flip();
  fileChannel02.write(byteBuffer);
}

//关闭相关的流
fileInputStream.close();
fileOutputStream.close();

public void test3(){
    FileChannel inChannel = null;
    FileChannel outChannel = null;
    try {
        // Paths.get("src/main/java/com/rin/pic/1.txt") 也可用拼串的方式
        inChannel = FileChannel.open(Paths.get("src/main/java/com/rin/pic", "1.txt"), StandardOpenOption.READ);
        // StandardOpenOption.CREATE_NEW 要写的文件不存在就创建，已经存在则报错
        outChannel = FileChannel.open(Paths.get("src/main/java/com/rin/pic", "4.txt"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE_NEW);

        // transferTo()写法
        inChannel.transferTo(0,inChannel.size(),outChannel);
        // transferFrom()写法
        // outChannel.transferFrom(inChannel,0,inChannel.size());

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (inChannel != null) {
            try {
                inChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (outChannel != null) {
            try {
                outChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public void test1() throws IOException {
  RandomAccessFile raf1 = new RandomAccessFile("src/main/java/com/rin/pic/1.txt","rw");
  // 获取通道
  FileChannel channel1 = raf1.getChannel();
  // 分配指定大小的缓冲区
  ByteBuffer buf1 = ByteBuffer.allocate(100);
  ByteBuffer buf2 = ByteBuffer.allocate(1024);

  // 分散读取
  ByteBuffer[] bufs = {buf1,buf2};
  channel1.read(bufs);

  for (ByteBuffer buf : bufs) {
    buf.flip();
  }
  System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
  System.out.println("-----------------");
  System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));

  // 聚集写入
  RandomAccessFile raf2 = new RandomAccessFile("src/main/java/com/rin/pic/2.txt","rw");
  FileChannel channel2 = raf2.getChannel();
  channel2.write(bufs);
}

//创建一个Buffer
ByteBuffer buffer = ByteBuffer.allocate(64);

//类型化方式放入数据
buffer.putInt(100);
buffer.putLong(9);
buffer.putChar('张');
buffer.putShort((short) 4);

//取出
buffer.flip();

System.out.println();
System.out.println(buffer.getInt());
System.out.println(buffer.getLong());
System.out.println(buffer.getChar());
System.out.println(buffer.getShort());

//创建一个buffer
ByteBuffer buffer = ByteBuffer.allocate(64);

for(int i = 0; i < 64; i++) {
  buffer.put((byte)i);
}

//读取
buffer.flip();

//得到一个只读的Buffer
ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
System.out.println(readOnlyBuffer.getClass());

//读取
while (readOnlyBuffer.hasRemaining()) {
  System.out.println(readOnlyBuffer.get());
}

readOnlyBuffer.put((byte)100); //ReadOnlyBufferException

// MappedByteBuffer 可让文件直接在内存(堆外内存)修改, 操作系统不需要拷贝一次
RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
//获取对应的通道
FileChannel channel = randomAccessFile.getChannel();

/**
  * 参数1: FileChannel.MapMode.READ_WRITE 使用的读写模式
  * 参数2： 0 ： 可以直接修改的起始位置
  * 参数3:  5: 是映射到内存的大小(不是索引位置) ,即将 1.txt 的多少个字节映射到内存
  * 可以直接修改的范围就是 0-5
  * 实际类型 DirectByteBuffer
  */
MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

mappedByteBuffer.put(0, (byte) 'H');
mappedByteBuffer.put(3, (byte) '9');
mappedByteBuffer.put(5, (byte) 'Y');//IndexOutOfBoundsException

randomAccessFile.close();
System.out.println("修改成功~~");

/**
 * Scattering：将数据写入到buffer时，可以采用buffer数组，依次写入  [分散]
 * Gathering: 从buffer读取数据时，可以采用buffer数组，依次读
 */
public class ScatteringAndGatheringTest {
  public static void main(String[] args) throws Exception {

    //使用 ServerSocketChannel 和 SocketChannel 网络
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);

    //绑定端口到socket ，并启动
    serverSocketChannel.socket().bind(inetSocketAddress);

    //创建buffer数组
    ByteBuffer[] byteBuffers = new ByteBuffer[2];
    byteBuffers[0] = ByteBuffer.allocate(5);
    byteBuffers[1] = ByteBuffer.allocate(2);

    //等客户端连接(telnet)
    SocketChannel socketChannel = serverSocketChannel.accept();
    int messageLength = 7;   //假定从客户端接收7个字节
    //循环的读取
    while (true) {

      int byteRead = 0;

      while (byteRead < messageLength ) {
        long l = socketChannel.read(byteBuffers);
        byteRead += l; //累计读取的字节数
        System.out.println("byteRead=" + byteRead);
        //使用流打印, 看看当前的这个buffer的position 和 limit
        Arrays.asList(byteBuffers).stream().map(buffer -> "postion=" + buffer.position() + ", limit=" + buffer.limit()).forEach(System.out::println);
      }

      //将所有的buffer进行flip
      Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());

      //将数据读出显示到客户端
      long byteWirte = 0;
      while (byteWirte < messageLength) {
        long l = socketChannel.write(byteBuffers); //
        byteWirte += l;
      }

      //将所有的buffer 进行clear
      Arrays.asList(byteBuffers).forEach(buffer-> {
        buffer.clear();
      });

      System.out.println("byteRead:=" + byteRead + " byteWrite=" + byteWirte + ", messagelength" + messageLength);
    }
  }
}

// 测试结果
byteRead=7
postion=5, limit=5
postion=2, limit=2
byteRead:=7 byteWrite=7, messagelength7

Selector selector = Selector.open();

ssChannel.register(selector, SelectionKey.OP_ACCEPT);

// 注册 监听事件
int interestSet = SelectionKey.OP_READ|SelectionKey.OP_WRITE;

public class TestNonBlockingNIO {
    // 客户端
    @Test
    public void client() throws IOException {
        // 1 获取通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        // 2 切换非阻塞模式
        socketChannel.configureBlocking(false);
        // 3 分配制定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 4 发送数据给服务端
        buf.put(new Date().toString().getBytes());
        buf.flip();
        socketChannel.write(buf);
        buf.clear();

        // 5 关闭通道
        socketChannel.close();
    }

    // 服务端
    @Test
    public void server() throws IOException {
        // 1 获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        // 2 切换非阻塞模式
        ssChannel.configureBlocking(false);
        // 3 绑定连接
        ssChannel.bind(new InetSocketAddress(9898));
        // 4 获取选择器
        Selector selector = Selector.open();
        // 5 将通道注册到选择器上,并且指定"监听接受事件"
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 6 轮询式的获取选择器上已经 准备就绪 的事件
        while (selector.select()>0){
            // 7 获取当前选择器中所有注册的 选择键(已就绪的监听事件)
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            // 8 迭代获取准备就绪的事件
            while (it.hasNext()){
                SelectionKey sk = it.next();
                // 9 判断具体什么事件准备就绪
                if (sk.isAcceptable()){
                    // 10 若接受就绪，获取客户端连接
                    SocketChannel sChannel = ssChannel.accept();
                    // 11 切换非阻塞模式
                    sChannel.configureBlocking(false);
                    // 12 将该通道注册到选择器上
                    sChannel.register(selector,SelectionKey.OP_READ);
                }else  if (sk.isReadable()){
                    // 13 获取当前选择器上 读就绪 状态的通道
                    SocketChannel sChannel = (SocketChannel) sk.channel();
                    // 14 读取数据
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    int len=0;
                    while ((len=sChannel.read(buf))>0){
                        buf.flip();
                        System.out.println(new String(buf.array(),0,len));
                        buf.clear();
                    }
                }
                // 15 取消选择键 SelectionKey(通过迭代器的remove方法即可取消当前选择键)
                it.remove();
            }
        }
    }
}

public class TestNonBlockingNIO2 {
    @Test
    public void send() throws IOException {
        DatagramChannel dc = DatagramChannel.open();
        dc.configureBlocking(false);
        ByteBuffer buf = ByteBuffer.allocate(1024);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String str = scanner.next();
            buf.put((new Date().toString()+":\n"+str).getBytes());
            buf.flip();
            dc.send(buf,new InetSocketAddress("127.0.0.1",9898));
            buf.clear();
        }
        dc.close();
    }

    @Test
    public void receive() throws IOException {
        DatagramChannel dc = DatagramChannel.open();
        dc.configureBlocking(false);
        dc.bind(new InetSocketAddress(9898));
        Selector selector = Selector.open();
        dc.register(selector, SelectionKey.OP_READ);
        while (selector.select()>0){
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()){
                SelectionKey sk = it.next();
                if (sk.isReadable()){
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    dc.receive(buf);
                    buf.flip();
                    System.out.println(new String(buf.array(),0,buf.limit()));
                    buf.clear();
                }
            }
            it.remove();
        }
    }
}

File file = new File("test.txt");
RandomAccessFile raf = new RandomAccessFile(file,"rw");

byte[] arr = new byte[(int)file.length()];
raf.read(arr);

Socket socket = new ServerSocket(8080).accept();
socket.getOutputStream().write(arr);

public class TestPipe {
    @Test
    public void test1() throws IOException {
        // 1 获取管道
        Pipe pipe = Pipe.open();
        // 2 将缓冲区中的数据写入管道
        ByteBuffer buf = ByteBuffer.allocate(1024);
        Pipe.SinkChannel sinkChannel = pipe.sink();
        buf.put("通过单向管道发送数据".getBytes());
        buf.flip(); // 写入管道也是从buf读数据，所以要flip
        sinkChannel.write(buf);
        // 3 读取缓冲区中的数据
        Pipe.SourceChannel sourceChannel = pipe.source();
        buf.flip();
        int len = sourceChannel.read(buf);
        System.out.println(new String(buf.array(),0,len));

        sourceChannel.close();
        sinkChannel.close();
    }
}

// 当 try 代码块结束时，自动释放资源。因此不需要显示的调用 close() 方法。该形式也称为“带资源的 try 语句”
try(需要关闭的资源声明){ 
  //可能发生异常的语句
}catch(异常类型 变量名){ 
  //异常的处理语句
}
......
finally{
	//一定执行的语句 
}