01 NIO 文件编程

作者: 攻城老狮 | 来源:发表于2021-09-29 08:45 被阅读0次

一 ByteBuffer

1 API使用案例

1.1 使用方式

向 buffer 写入数据，例如调用 channel.read(buffer)
调用 flip() 切换至读模式
- flip会使得buffer中的limit变为position，position变为0
从 buffer 读取数据，例如调用 buffer.get()
调用 clear() 或者compact()切换至写模式
- 调用clear()方法时position=0，limit变为capacity
- 调用compact()方法时，会将缓冲区中的未读数据压缩到缓冲区前面
重复以上步骤

1.2 使用ByteBuffer读取文件中的内容

public class ByteBufferTest {
    public static void main(String[] args) {
        // 获得FileChannel
        try (FileChannel channel = new FileInputStream("data.txt").getChannel()) {
            // 获得缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(10);
            int hasNext = 0;
            StringBuilder sb = new StringBuilder();
            while ((hasNext = channel.read(buffer))>0){
                // 切换读模式
                buffer.flip();
                // 当buffer中还有数据时，获取其中的数据
                while (buffer.hasRemaining()){
                    sb.append((char)buffer.get());
                }
                // 切换写模式
                buffer.clear();
            }
            System.out.println(sb.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

result

0123456789abcdef

2 内部结构

2.1 核心属性解读

字节缓冲区的父类Buffer中有几个核心属性

capacity：缓冲区的容量。通过构造函数赋予，一旦设置，无法更改
limit：缓冲区的界限。位于limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量
position：下一个读写位置的索引。缓冲区的位置不能为负，并且不能大于limit
mark：记录当前position的值。position被改变后，可以通过调用reset() 方法恢复到mark的位置。

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

2.2 API调用对核心属性的修改

put()方法

put()方法可以将一个数据放入到缓冲区中。
进行该操作后，postition的值会+1，指向下一个可以放入的位置。capacity = limit ，为缓冲区容量的值。

20201109145709.png

flip()方法

flip()方法会切换对缓冲区的操作模式，由写->读
进行该操作后 position = 0 ， limit 指向最后一个元素的下一个位置，capacity不变

20201109145753.png

get()方法

get()方法会读取缓冲区中的一个值
进行该操作后，position会+1，如果超过了limit则会抛出异常
注意：get(i)方法不会改变position的值

20201109145822.png

rewind()方法

该方法只能在读模式下使用
rewind()方法后，会恢复position、limit和capacity的值，变为进行get()前的值

20201109145852.png

clean()方法

clean()方法会将缓冲区中的各个属性恢复为最初的状态，position = 0, capacity = limit
此时缓冲区的数据依然存在，处于“被遗忘”状态，下次进行写操作时会覆盖这些数据

20201109145905.png

mark() reset()方法

mark()方法会将postion的值保存到mark属性中
reset()方法会将position的值改为mark中保存的值

compact()方法

compact会把未读完的数据向前压缩，然后切换到写模式
数据前移后，原位置的值并未清零，写时会覆盖之前的值
此方法是ByteBuffer的方法，不是Buffer的方法

20210412155726.png

注意：clear只是对position、limit、mark进行重置，而compact在对position进行设置，以及limit、mark进行重置的同时，还涉及到数据在内存中拷贝（会调用arraycopy）。所以compact比clear更耗性能。但compact能保存你未读取的数据，将新数据追加到为读取的数据之后；而clear则不行，若你调用了clear，则未读取的数据就无法再读取到了

2.3 相关方法调用

2.3.1 ByteBuffer调试工具类

导入netty依赖

<dependency>
  <groupId>io.netty</groupId>
  <artifactId>netty-all</artifactId>
  <version>4.1.51.Final</version>
</dependency>

工具类

import java.nio.ByteBuffer;

import io.netty.util.internal.MathUtil;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.MathUtil.*;


/**
 * @author Panwen Chen
 * @date 2021/4/12 15:59
 */
public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(StringUtil.NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (MathUtil.isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        StringUtil.NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        StringUtil.NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(StringUtil.NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(StringUtil.NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }
}

2.3.2 调用ByteBuffer方法查看内部结构

public class ByteBufferCoreTest {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        // 向buffer中写入1个字节的数据
        buffer.put((byte)97);
        ByteBufferUtil.debugAll(buffer);
        // 向buffer中写入4个字节的数据
        buffer.put(new byte[]{98,99,100,101});
        ByteBufferUtil.debugAll(buffer);
        // 切换读模式，获取数据
        buffer.flip();
        ByteBufferUtil.debugAll(buffer);
        System.out.println(buffer.get());
        System.out.println(buffer.get());
        ByteBufferUtil.debugAll(buffer);
                // 使用compact切换写模式
        buffer.compact();
        ByteBufferUtil.debugAll(buffer);
        // 再次写入
        buffer.put((byte)102);
        buffer.put((byte)103);
        ByteBufferUtil.debugAll(buffer);
    }
}

result

+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 00 00 00 00 00 00 00 00 00                   |a.........      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65 00 00 00 00 00                   |abcde.....      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65 00 00 00 00 00                   |abcde.....      |
+--------+-------------------------------------------------+----------------+
97
98
+--------+-------------------- all ------------------------+----------------+
position: [2], limit: [5]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65 00 00 00 00 00                   |abcde.....      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [3], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 63 64 65 64 65 00 00 00 00 00                   |cdede.....      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 63 64 65 66 67 00 00 00 00 00                   |cdefg.....      |
+--------+-------------------------------------------------+----------------+

2.4 字符串和ByteBuffer转换

方法一，通过StandardCharsets的encode和decode方法

public class Translate {
    public static void main(String[] args) {
        String str1 = "Hello World";
        String str2 = "";

        // 通过StandardCharsets的encode方法获得ByteBuffer
        // 此时获得的ByteBuffer为读模式，无需通过flip切换模式
        ByteBuffer buffer = StandardCharsets.UTF_8.encode(str1);
        ByteBufferUtil.debugAll(buffer);

        //如果差人一次get()则最后打印的字符串变为 ello World，原因是position目前的位置变为1，导致读取时忽略了position=0位置的数据
        //System.out.println(buffer.get()); 
      
        // 将缓冲区中的数据转化为字符串
        // 通过StandardCharsets解码，获得CharBuffer，再通过toString获得字符串
        str2 = StandardCharsets.UTF_8.decode(buffer).toString();
        System.out.println(str2);
        ByteBufferUtil.debugAll(buffer);
    }
}

result

+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [11]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 57 6f 72 6c 64 00             |Hello World.    |
+--------+-------------------------------------------------+----------------+
Hello World
+--------+-------------------- all ------------------------+----------------+
position: [11], limit: [11]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 57 6f 72 6c 64 00             |Hello World.    |
+--------+-------------------------------------------------+----------------+

方法二，将字节数组传给ByteBuffer的wrap()方法，通过该方法获得ByteBuffer。同样无需调用flip方法切换为读模式

public class Translate {
    public static void main(String[] args) {
        String str1 = "Hello World";
        String str2 = "";

        ByteBuffer buffer = ByteBuffer.wrap(str1.getBytes());
        ByteBufferUtil.debugAll(buffer);

        str2 = StandardCharsets.UTF_8.decode(buffer).toString();
        System.out.println(str2);
        ByteBufferUtil.debugAll(buffer);
    }
}

result

+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [11]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 57 6f 72 6c 64                |Hello World     |
+--------+-------------------------------------------------+----------------+
Hello World
+--------+-------------------- all ------------------------+----------------+
position: [11], limit: [11]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 57 6f 72 6c 64                |Hello World     |
+--------+-------------------------------------------------+----------------+

2.5 粘包与半包

2.5.1 现象

网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有3条为

Hello,world\n
I’m Nyima\n
How are you?\n

变成了下面的两个 byteBuffer (粘包，半包)

Hello,world\nI’m Nyima\nHo
w are you?\n

2.5.2 解决办法

public class ByteBufferPackageTest {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(32);
        // 模拟粘包+半包
        buffer.put("Hello,world\nI'm Nyima\nHo".getBytes());
        // 调用split函数处理
        split(buffer);
        buffer.put("w are you?\n".getBytes());
        split(buffer);
    }

    public static void split(ByteBuffer buffer){
        // 切换为读模式
        buffer.flip();
        for (int i = 0; i < buffer.limit(); i++) {
            // 遍历寻找分隔符
            // get(i)不会移动position
            if (buffer.get(i) == '\n'){
                // 缓冲区长度
                int length = i + 1 - buffer.position();
                ByteBuffer target = ByteBuffer.allocate(length);
                // 将前面的内容写入target缓冲区
                for (int j = 0; j < length; j++) {
                    // 将buffer中的数据写入target中
                    target.put(buffer.get());
                }
                ByteBufferUtil.debugAll(target);
            }
        }
        // 切换为写模式，但是缓冲区可能未读完，这里需要使用compact
        buffer.compact();
    }
}

result

+--------+-------------------- all ------------------------+----------------+
position: [12], limit: [12]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 2c 77 6f 72 6c 64 0a             |Hello,world.    |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [10], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 49 27 6d 20 4e 79 69 6d 61 0a                   |I'm Nyima.      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [13], limit: [13]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 6f 77 20 61 72 65 20 79 6f 75 3f 0a          |How are you?.   |
+--------+-------------------------------------------------+----------------+

二文件编程

1 FileChannel

FileChannel只能在阻塞模式下工作，所以无法搭配Selector

1.1 获取channel

不能直接打开 FileChannel，必须通过 FileInputStream、FileOutputStream 或者 RandomAccessFile 来获取 FileChannel，它们都有 getChannel 方法

通过 FileInputStream 获取的 channel 只能读
通过 FileOutputStream 获取的 channel 只能写
通过 RandomAccessFile 是否能读写根据构造 RandomAccessFile 时的读写模式决定

1.2 读取channel

通过 FileInputStream 获取channel，通过read方法将数据写入到ByteBuffer中，read方法的返回值表示读到了多少字节，若读到了文件末尾则返回-1

int readBytes = channel.read(buffer);

根据返回值判断是否读取完毕

while(channel.read(buffer) > 0) {
    // 进行对应操作
    ...
}

1.3 写入channel

因为channel也是有大小的，所以 write 方法并不能保证一次将 buffer 中的内容全部写入 channel。需要按照以下规则进行写入

// 通过hasRemaining()方法查看缓冲区中是否还有数据未写入到通道中
while(buffer.hasRemaining()) {
    channel.write(buffer);
}

1.4 关闭channel

通道需要close，一般情况通过try-with-resource进行关闭，最好使用以下方法获取stream以及channel，避免某些原因使得资源未被关闭

public class TestChannel {
    public static void main(String[] args) throws IOException {
        try (FileInputStream fis = new FileInputStream("stu.txt");
             FileOutputStream fos = new FileOutputStream("student.txt");
             FileChannel inputChannel = fis.getChannel();
             FileChannel outputChannel = fos.getChannel()) {
            
            // 执行对应操作
            ...
                
        }
    }
}

2 两个channel传输数据

使用transferTo方法可以快速、高效地将一个channel中的数据传输到另一个channel中，但一次只能传输2G的内容，transferTo底层使用了零拷贝技术

public class TransferToTest {
    public static void main(String[] args) {
        try (FileChannel inputChannel = new FileInputStream("data.txt").getChannel();
             FileChannel outputChannel = new FileOutputStream("data2.txt").getChannel()) {
            // 参数：inputChannel的起始位置，传输数据的大小，目的channel
            // 返回值为传输的数据的字节数
            // transferTo一次只能传输2G的数据
            inputChannel.transferTo(0,inputChannel.size(),outputChannel);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

当传输的文件大于2G时，需要使用以下方法进行多次传输

public class TransferToTest {
    public static void main(String[] args) {
        try (FileChannel inputChannel = new FileInputStream("data.txt").getChannel();
             FileChannel outputChannel = new FileOutputStream("data2.txt").getChannel()) {
            long size = inputChannel.size();
            long capacity = inputChannel.size();
            // 分多次传输
            while (capacity > 0){
                // transferTo返回值为传输了的字节数
                capacity -= inputChannel.transferTo(size-capacity,capacity,outputChannel);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3 Path和Paths

Path 用来表示文件路径
Paths 是工具类，用来获取 Path 实例

Path source = Paths.get("1.txt"); // 相对路径 不带盘符 使用 user.dir 环境变量来定位 1.txt
Path source = Paths.get("d:\\1.txt"); // 绝对路径代表了  d:\1.txt 反斜杠需要转义
Path source = Paths.get("d:/1.txt"); // 绝对路径同样代表了  d:\1.txt
Path projects = Paths.get("d:\\data", "projects"); // 代表了  d:\data\projects

. 代表了当前路径
.. 代表了上一级路径

4 Files

4.1 查找

Path path = Paths.get("helloword/data.txt");
System.out.println(Files.exists(path)); //检查文件是否存在

4.2 创建

创建一级目录
- 如果目录已存在，会抛异常 FileAlreadyExistsException
- 不能一次创建多级目录，否则会抛异常 NoSuchFileException

Path path = Paths.get("helloword/d1");
Files.createDirectory(path);

Path path = Paths.get("helloword/d1/d2");
Files.createDirectories(path);

4.3 拷贝和移动

拷贝文件
- 如果文件已存在，会抛异常 FileAlreadyExistsException

Path source = Paths.get("helloword/data.txt");
Path target = Paths.get("helloword/target.txt");
Files.copy(source, target);
//如果希望用 source 覆盖掉 target，需要用 StandardCopyOption 来控制
//Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

移动文件

Path source = Paths.get("helloword/data.txt");
Path target = Paths.get("helloword/data.txt");
//StandardCopyOption.ATOMIC_MOVE 保证文件移动的原子性
Files.move(source, target, StandardCopyOption.ATOMIC_MOVE);

4.4 删除

删除文件
- 如果文件不存在，会抛异常 NoSuchFileException

Path target = Paths.get("helloword/target.txt");
Files.delete(target);

删除目录
- 如果目录还有内容，会抛异常 DirectoryNotEmptyException

Path target = Paths.get("helloword/d1");
Files.delete(target);

4.5 遍历文件

可以使用Files工具类中的walkFileTree(Path, FileVisitor)方法，其中需要传入两个参数

Path：文件起始路径
FileVisitor：文件访问器，

使用访问者模式
- 接口的实现类
  
  SimpleFileVisitor
  
  有四个方法
  - preVisitDirectory：访问目录前的操作
  - visitFile：访问文件的操作
  - visitFileFailed：访问文件失败时的操作
  - postVisitDirectory：访问目录后的操作

public class WalkFileTreeTest {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("/Users/yorick/Documents/leisure");
        // 文件目录数目
        AtomicInteger dirCount = new AtomicInteger();
        // 文件数目
        AtomicInteger fileCount = new AtomicInteger();

        Files.walkFileTree(path,new SimpleFileVisitor<Path>(){
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                System.out.println("===>"+dir);
                // 增加文件目录数
                dirCount.incrementAndGet();
                return super.preVisitDirectory(dir, attrs);
            }

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println(file);
                // 增加文件数
                fileCount.incrementAndGet();
                return super.visitFile(file, attrs);
            }
        });
        // 打印数目
        System.out.println(dirCount);
        System.out.println(fileCount);
    }
}

01 NIO 文件编程

一 ByteBuffer

1 API使用案例

1.1 使用方式

1.2 使用ByteBuffer读取文件中的内容

2 内部结构

2.1 核心属性解读

2.2 API调用对核心属性的修改

2.3 相关方法调用

2.3.1 ByteBuffer调试工具类

2.3.2 调用ByteBuffer方法查看内部结构

2.4 字符串和ByteBuffer转换

2.5 粘包与半包

2.5.1 现象

2.5.2 解决办法

二文件编程

1 FileChannel

1.1 获取channel

1.2 读取channel

1.3 写入channel

1.4 关闭channel

2 两个channel传输数据

3 Path和Paths

4 Files

4.1 查找

4.2 创建

4.3 拷贝和移动

4.4 删除

4.5 遍历文件

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

01 NIO 文件编程

一 ByteBuffer

1 API使用案例

1.1 使用方式

1.2 使用ByteBuffer读取文件中的内容

2 内部结构

2.1 核心属性解读

2.2 API调用对核心属性的修改

2.3 相关方法调用

2.3.1 ByteBuffer调试工具类

2.3.2 调用ByteBuffer方法查看内部结构

2.4 字符串和ByteBuffer转换

2.5 粘包与半包

2.5.1 现象

2.5.2 解决办法

二 文件编程

1 FileChannel

1.1 获取channel

1.2 读取channel

1.3 写入channel

1.4 关闭channel

2 两个channel传输数据

3 Path和Paths

4 Files

4.1 查找

4.2 创建

4.3 拷贝和移动

4.4 删除

4.5 遍历文件

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

二文件编程