Java NIO

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;

public abstract class ChannelTest {

    public static void main(String[] args) {
        String filePath = "/Users/cig01/1.txt";
        System.out.println("Using FileInputStream");
        method1(filePath);
        System.out.println("Using NIO");
        method2(filePath);
    }

    /* 使用FileInputStream读取文件 */
    public static void method1(String filePath) {
        InputStream in = null;
        try {
            in = new BufferedInputStream(new FileInputStream(filePath));

            byte[] buf = new byte[8];    // 这里仅为演示，一般会使用更大的数组。

            int bytesRead = in.read(buf);
            while (bytesRead != -1) {
                for (int i = 0; i < bytesRead; i++) {
                    System.out.print((char) buf[i]);
                }
                bytesRead = in.read(buf);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /* 使用NIO读取文件 */
    public static void method2(String filePath) {
        FileChannel fileChannel = null;
        try {
            Path path = Paths.get(filePath);
            fileChannel =  FileChannel.open(path);

            ByteBuffer buf = ByteBuffer.allocate(8);  // 这里仅为演示，一般会使用更大的buffer。

            int bytesRead = fileChannel.read(buf);    // 从channel中读数据

            while (bytesRead != -1) {
                System.out.println("Number of bytes read: " + bytesRead);

                buf.flip();

                System.out.print("Buffer contents: ");

                while (buf.hasRemaining()) {
                    System.out.print((char) buf.get());
                }

                System.out.println();

                buf.clear();
                bytesRead = fileChannel.read(buf);    // 从channel中读数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileChannel != null) {
                    fileChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

File.read(fileDesc, buf, len);
Socket.send(socket, buf, len);

import static java.nio.file.StandardOpenOption.READ;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.concurrent.Future;

public class TestAsyncChannelAndFuture {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("/Users/cig01/test/file1");

        try (AsynchronousFileChannel afc = AsynchronousFileChannel.open(path, READ)) {
            int fileSize = (int) afc.size();
            ByteBuffer dataBuffer = ByteBuffer.allocate(fileSize);

            Future<Integer> result = afc.read(dataBuffer, 0);

            int readBytes = result.get();
            // 当读取结束后result.get()才返回，调用get()前使用result.isDone()可测试是否结束

            System.out.format("%s bytes read from %s%n", readBytes, path);

            System.out.format("Read data is:%n");
            byte[] byteData = dataBuffer.array();
            Charset cs = Charset.forName("UTF-8");
            String data = new String(byteData, cs);
            System.out.println(data);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

import static java.nio.file.StandardOpenOption.READ;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.nio.file.Paths;

public class TestAsyncChannelAndCompletionHandler {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("/Users/cig01/test/file1");
        AsynchronousFileChannel afc = AsynchronousFileChannel.open(path, READ);
        ReadHandler handler = new ReadHandler();
        int fileSize = (int) afc.size();
        ByteBuffer dataBuffer = ByteBuffer.allocate(fileSize);

        Attachment attach = new Attachment();
        attach.asyncChannel = afc;
        attach.buffer = dataBuffer;
        attach.path = path;

        afc.read(dataBuffer, 0, attach, handler);

        System.out.println("Sleeping for 5 seconds...");
        Thread.sleep(5000);  // 等待读取完成，否则进程会提前退出
    }
}

class Attachment {
    public Path path;
    public ByteBuffer buffer;
    public AsynchronousFileChannel asyncChannel;
}

class ReadHandler implements CompletionHandler<Integer, Attachment> {
    @Override
    public void completed(Integer result, Attachment attach) {
        System.out.format("%s bytes read from %s%n", result, attach.path);
        System.out.format("Read data is:%n");
        byte[] byteData = attach.buffer.array();
        Charset cs = Charset.forName("UTF-8");
        String data = new String(byteData, cs);
        System.out.println(data);
        try {
            // Close the channel
            attach.asyncChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void failed(Throwable e, Attachment attach) {
        System.out.format("Read operation on %s file failed." + "The error is: %s%n", attach.path, e.getMessage());
        try {
            // Close the channel
            attach.asyncChannel.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }
}