Java NIO 讀取文件、寫入文件、讀取寫入混合

前言

Java NIO(new/inputstream outputstream)使用通道、緩沖來操作流，所以要深刻理解這些概念，尤其是，緩沖中的數據結構（當前位置(position)、限制(limit)、容量(capacity)）,這些知識點要通過寫程序慢慢體會。

 

NIO vs  傳統IO

NIO是面向緩沖、通道的；傳統IO面向流

通道是雙向的既可以寫、也可以讀；傳統IO只能是單向的

NIO可以設置為異步；傳統IO只能是阻塞，同步的

 

 

緩沖區結構圖

NIO是面向緩沖區的，緩沖區可以理解為一塊內存，有大小。緩沖區有位置、界限、容量幾個概念。

 

capacity：容量，緩沖區的大小

limit：限制，表示最大的可讀寫的數量

position：當前位置，每當讀寫，當前位置都會加一

 

flip和clear方法，內部就操作這三個變量。

 

 

 

緩沖區常用方法

clear：將當前位置設置為0，限制設置為容量，目的是盡最大可能讓字節，由通道讀取到緩沖中

flip：當前位置置為限制，然后將當前位置置為0，目的是將有數據部分的字節，由緩沖寫入到通道中。通常用在讀與寫之間。

 

讀寫文件代碼

package com.nio;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;

public class TestJavaNio {

    public static String pathname = "d://read.txt";
    public static String filename = "d://write.txt";

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        readNIO();
        writeNIO();
        //testReadAndWriteNIO();
    }

    public static void readNIO() {
        FileInputStream fin = null;
        try {
            fin = new FileInputStream(new File(pathname));
            FileChannel channel = fin.getChannel();

            int capacity = 1000;// 字節
            ByteBuffer bf = ByteBuffer.allocate(capacity);
            System.out.println("限制是：" + bf.limit() + ",容量是：" + bf.capacity() + " ,位置是：" + bf.position());
            int length = -1;

            while ((length = channel.read(bf)) != -1) {

                /*
                 * 注意，讀取后，將位置置為0，將limit置為容量, 以備下次讀入到字節緩沖中，從0開始存儲
                 */
                bf.clear();
                byte[] bytes = bf.array();
                System.out.println("start..............");

                String str = new String(bytes, 0, length);
                System.out.println(str);
                //System.out.write(bytes, 0, length);

                System.out.println("end................");

                System.out.println("限制是：" + bf.limit() + "容量是：" + bf.capacity() + "位置是：" + bf.position());

            }

            channel.close();

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

    public static void writeNIO() {
        FileOutputStream fos = null;
        try {

            fos = new FileOutputStream(new File(filename));
            FileChannel channel = fos.getChannel();
            ByteBuffer src = Charset.forName("utf8").encode("你好你好你好你好你好");
            // 字節緩沖的容量和limit會隨着數據長度變化，不是固定不變的
            System.out.println("初始化容量和limit：" + src.capacity() + ","
                    + src.limit());
            int length = 0;

            while ((length = channel.write(src)) != 0) {
                /*
                 * 注意，這里不需要clear，將緩沖中的數據寫入到通道中后 第二次接着上一次的順序往下讀
                 */
                System.out.println("寫入長度:" + length);
            }

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

    public static void testReadAndWriteNIO() {
        FileInputStream fin = null;
        FileOutputStream fos = null;
        try {
            fin = new FileInputStream(new File(pathname));
            FileChannel channel = fin.getChannel();

            int capacity = 100;// 字節
            ByteBuffer bf = ByteBuffer.allocate(capacity);
            System.out.println("限制是：" + bf.limit() + "容量是：" + bf.capacity() + "位置是：" + bf.position());
            int length = -1;

            fos = new FileOutputStream(new File(filename));
            FileChannel outchannel = fos.getChannel();


            while ((length = channel.read(bf)) != -1) {

                //將當前位置置為limit，然后設置當前位置為0，也就是從0到limit這塊，都寫入到同道中
                bf.flip();

                int outlength = 0;
                while ((outlength = outchannel.write(bf)) != 0) {
                    System.out.println("讀，" + length + "寫," + outlength);
                }

                //將當前位置置為0，然后設置limit為容量，也就是從0到limit（容量）這塊，
                //都可以利用，通道讀取的數據存儲到
                //0到limit這塊
                bf.clear();

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fin != null) {
                try {
                    fin.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}