java I/O,NIO,OKio

I/O: 程序内部和外部进⾏数据交互的过程，就叫输⼊输出

Java I/O 作⽤:和外界做数据交互

	
	
    private static void io1() {
        try (OutputStream outputStream = new FileOutputStream("./text.txt")) {
            outputStream.write('a');
            outputStream.write('b');
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
  	
  	private static void io2() {
        try (OutputStream outputStream = new FileOutputStream("./text.txt");
             Writer writer = new OutputStreamWriter(outputStream);
             BufferedWriter bufferedWriter = new BufferedWriter(writer)) {
            bufferedWriter.write('a');
            bufferedWriter.write('b');
            //bufferedWriter.flush(); //中途使用就要手动flush
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

	
	private static void io3() {
        try (InputStream inputStream = new FileInputStream("./text.txt");
             OutputStream outputStream = new FileOutputStream("./text2.txt")) {
            byte[] data = new byte[1024];
            int read;
            while ((read = inputStream.read(data)) != -1) {
                outputStream.write(data, 0, read);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

	
    private static void io4() {
        try (InputStream inputStream = new FileInputStream("./text.txt");
        Reader reader = new InputStreamReader(inputStream); 
        BufferedReader bufferedReader = new BufferedReader(reader)) {
            System.out.println(bufferedReader.readLine());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

NIO 和 IO 的区别有⼏点：

传统 IO ⽤的是插管道的⽅式，⽤的是 Stream；NIO ⽤的也是插管道的⽅式，⽤的是 Channel。
NIO 的 Channel是双向的NIO 也⽤到 buffer
它的 Buffer 可以被操作
它强制使⽤ Buffer
它的 buffer 不好⽤NIO 有⾮阻塞式的⽀持
只是⽀持⾮阻塞式，⽽不是全是⾮阻塞式。默认是阻塞式的
⽽且就算是⾮阻塞式，也只是⽹络交互⽀持，⽂件交互是不⽀持的

⽤ NIO 来读⽂件的写法：
使⽤fine.getChannel() 获取到 Channel
然后创建⼀个 Buffer
再⽤ channel.read(buffer)，把⽂件内容读进去
读完以后，⽤ flip() 翻⻚
开始使⽤ Buffer
使⽤完之后记得clear() ⼀下

	
    private static void nio1() {
        try {
            RandomAccessFile file = new RandomAccessFile("./text.txt", "a");
            FileChannel channel = file.getChannel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            channel.read(byteBuffer);
            byteBuffer.flip();
            System.out.println(Charset.defaultCharset().decode(byteBuffer));
            byteBuffer.clear();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
	
    private static void nio2() {
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);
            Selector selector = Selector.open();
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            SocketChannel socketChannel = serverSocketChannel.accept();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            while (socketChannel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

它也是基于插管的，⽽且是单向的，输⼊源叫 Source，输出⽬标叫 Sink⽀持 Buffer
向 NIO ⼀样，可以对 Buffer 进⾏操作
但不强制使⽤ Buffer

	
	 private static void okio1() {
	       Buffer buffer = new Buffer();
	       try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(buffer.outputStream())) {
	           objectOutputStream.writeUTF("a");
	           objectOutputStream.writeBoolean(true);
	           objectOutputStream.writeChar('b');
	           //objectOutputStream.flush();//中途使用就要手动flush
	           ObjectInputStream objectInputStream = new ObjectInputStream(buffer.inputStream());
	           System.out.println(objectInputStream.readUTF());
	           System.out.println(objectInputStream.readBoolean());
	       } catch (IOException e) {
	           e.printStackTrace();
	       }
	   }
	   
    
	  private static void okio2() {
	      try (Source source = Okio.buffer(Okio.source(new File("./text.txt")))) {
	          Buffer buffer = new Buffer();
	          source.read(buffer, 1024);
	          System.out.println(buffer.readUtf8Line());
	          System.out.println(buffer.readUtf8Line());
	      } catch (FileNotFoundException e) {
	          e.printStackTrace();
	      } catch (IOException e) {
	          e.printStackTrace();
	      }
	  }