commons-io之FileUtils、IOUtils

笔者日常：这是笔者来深圳后的第一篇博客~记录一下，2019-06-25。

---

commons-io简单说明：

Common IO 是一个工具库，用来帮助开发IO功能 它包括6个主要部分：

1. 一些工具类：包括一些静态方法来执行常用任务。

2. 输入：InputStream 和 Reader 实现。

3. 输出：OutputStream 和 Writer 实现。

4. 过滤器：多种文件过滤器实现(定义了 IOFileFilter接口，同时继承了 FileFilter 和 FilenameFilter 接口)。

5. 比较器：用于文件比较的多种java.util.Comparatot实现。

6. 文件监听器：监听文件系统事件的组件。

---

相对比较常用的有两个工具类：FileUtils和IOUtils，本文主要学习这两个工具类的部分常用方法。

---

使用测试：

软硬件环境说明：Windows10、IntelliJ IDEA、SpringBoot 2.1.5.RELEASE

准备工作：在pom.xml中引入commons-io的依赖

    commons-io
    commons-io
    2.6

FileUtils：

声明一：下面示例的只是FileUtils一些相对常用的方法。

声明二：移动和复制用法差不多，在下面的示例中，本人只示例了copy,要使用move的话，可类比这使用即可。

• 将指定大小的bytes， 转换为易读的单位

/**
 * 将指定大小的bytes， 转换为易读的单位， 如： bytes、KB、MB、GB、TB……
 *
 * @date 2019/6/13 19:09
 */
@Test
public void testOne() {
    String resultOne = FileUtils.byteCountToDisplaySize(25L);
    Assert.assertEquals("25 bytes", resultOne);

    String resultTwo = FileUtils.byteCountToDisplaySize(25 * 1024 *1024L);
    Assert.assertEquals("25 MB", resultTwo);

    String resultThree = FileUtils.byteCountToDisplaySize(25 * 1024 * 1024 *1024L);
    Assert.assertEquals("25 GB", resultThree);
}

• 将泛型为 File的集合 转换为数组

/**
 * 将泛型为 File的集合 转换为数组
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testTwo() {
    List list = new ArrayList<>(8);
    list.add(new File(BASE_DIR + File.separator + "a.txt"));
    list.add(new File(BASE_DIR + File.separator + "a.txt"));
    list.add( new File(BASE_DIR + File.separator + "c.txt"));
    File[] fileArray = FileUtils.convertFileCollectionToFileArray(list);
    for (int i = 0; i < fileArray.length; i++) {
        Assert.assertEquals(list.get(i), fileArray[i]);
    }
    // System.out.println(Arrays.deepToString(fileArray));
}

• 查找指定目录下的(所有)文件

/**
 * 查找指定目录下的(所有)文件
 * 注:既能查找出有后缀名的文件，又能查找出无后缀名的文件
 *
 * public static Collection listFiles(final File directory, final String[] extensions, final boolean recursive)
 * 方法的三个参数分别是:
 *  File directory: 指定文件夹目录
 *  String[] extensions:筛选出指定后缀名的文件，若为null,表示不作筛选，直接返回查到的所有文件
 *  boolean recursive:是否递归
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testThree() {
    // 筛选出指定后缀名的文件
    String[] extensions = new String[]{"java", "xml", "txt"};
    // null表示不作筛选，FileUtils.listFiles会直接返回所有的文件
    // String[] extensions = null;

    // 遍历查找指定目录下的所有文件
    Collection filesList = FileUtils.listFiles(new File(BASE_DIR ), extensions, true);
    for (File file: filesList) {
        System.out.println(file.getAbsolutePath());
    }
}

/**
 * 查找指定目录下的(所有)文件
 * 注:既能查找出有后缀名的文件，又能查找出无后缀名的文件
 * 注:此方法与testThree方法功能几乎一致，不过 在public static Collection listFiles(final File directory, final IOFileFilter fileFilter, final IOFileFilter dirFilter)
 *    方法，比testThree中的FileUtils.listFiles方法更灵活。
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testFour() {
    // (递归)遍历查找指定目录下的所有文件
    // Collection filesList = FileUtils.listFiles(new File(BASE_DIR ), TrueFileFilter.INSTANCE, TrueFileFilter.INSTANCE);
    /*
     * (递归)遍历查找指定目录下的所有文件，返回以【m.xml】结尾的文件
     * 如果筛选条件有多个的话，可以使用FileFilterUtils.and()、FileFilterUtils.or()来实现
     */
    Collection filesList = FileUtils.listFiles(new File(BASE_DIR ), FileFilterUtils.suffixFileFilter("m.xml"), TrueFileFilter.INSTANCE);
    for (File file: filesList) {
        System.out.println(file.getAbsolutePath());
    }
}

• 比较两个文件中的内容是否完全一致

/**
 * 比较两个文件中的内容是否完全一致
 * 注:有一个空格都不算一致
 * 注:若两个文件都不存在，那么也算一致
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testSix() throws IOException {
    boolean result = FileUtils.contentEquals(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"),
                                             new File("C:\\Users\\JustryDeng\\Desktop\\b.txt"));
    System.out.println(result);
}

• 将指定目录下的所有内容(文件、文件夹)，拷贝到一个新的目录下

/**
 * 将指定目录下的所有内容(文件、文件夹)，拷贝到一个新的目录下
 * 注:若这个新的目录不存在，那么会自动创建
 * 注:若目的文件夹下存在相同名字的文件、文件夹，那么会进行覆盖
 * 注:只拷贝源目录下的内容，源目录不会被拷贝
 * 注:其有一个比较实用的重载方法copyDirectory(final File srcDir, final File destDir,final FileFilter filter)，
 *    该方法能对源文件、文件夹进行过滤，只有满足FileFilter的文件/文件件，才会被拷贝进 目的文件夹下， 可详见源码
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testSeven() throws IOException {
    FileUtils.copyDirectory(new File(BASE_DIR), new File("C:\\Users\\JustryDeng\\Desktop\\xyz\\jpg"));
}

• 将指定目录以及该目录下的的所有内容(文件、文件夹)，拷贝到一个新的目录下

/**
 * 将指定目录以及该目录下的的所有内容(文件、文件夹)，拷贝到一个新的目录下
 * 注:若这个新的目录不存在，那么会自动创建
 * 注:若目的文件夹下存在相同名字的文件、文件夹，那么会进行覆盖
 * 注:与testSeven不同的是，这里直接连源目录都一起进行拷贝了
 * 注:其有一个比较实用的重载方法copyDirectory(final File srcDir, final File destDir,final FileFilter filter)，
 *    该方法能对源文件、文件夹进行过滤，只有满足FileFilter的文件/文件件，才会被拷贝进 目的文件夹下， 可详见源码
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testEight() throws IOException {
    FileUtils.copyDirectoryToDirectory(new File(BASE_DIR), new File("C:\\Users\\JustryDeng\\Desktop\\xyz\\jpg"));
}

• 拷贝一个文件，到一个新的文件

/**
 * 拷贝一个文件，到一个新的文件
 *
 * 注:FileUtils.copyFile方法只能拷贝文件，不能拷贝文件夹
 * 注:新文件的存放路径如果不存在，会自动创建
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testNine() throws IOException {
    FileUtils.copyFile(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"), new File("C:\\Users\\JustryDeng\\Desktop\\lv\\re.txt"));
}

• 拷贝一个文件，到一个输出流

/**
 * 拷贝一个文件，到一个输出流
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testTen() throws IOException {
    try (OutputStream os = System.out) {
        FileUtils.copyFile(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"), os);
        String str = os.toString();
        System.out.println(str);
    }
}

• 拷贝一个输入流，到一个文件

/**
 * 拷贝一个输入流，到一个文件
 * 注:会自动创建文件
 * 注:如果路径不存在的话，会自动创建相关文件夹
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testEleven() throws IOException {
    File tmpFile = new File("C:\\Users\\JustryDeng\\Desktop\\b.txt");
    try (InputStream is = new FileInputStream(tmpFile)) {
        // 等价于copyToFile(InputStream source, File destination)
        FileUtils.copyInputStreamToFile(is, new File("C:\\Users\\JustryDeng\\Desktop\\mq\\tmp\\b2.txt"));
    }
}

• 拷贝文件到指定目录下

/**
 * 拷贝文件到指定目录下
 * 注:如果目标目录不存在，那么会自动创建
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testTwelve() throws IOException {
    FileUtils.copyFileToDirectory(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"),
            new File("C:\\Users\\JustryDeng\\Desktop\\mq\\tmp\\"));
}

• 拷贝【文件】或【文件夹】到指定目录下

/**
 * 拷贝【文件】或【文件夹】 到 指定目录下
 * 注:如果目标目录不存在，那么会自动创建
 * 注:如果拷贝的是文件夹，那么连该文件夹下的所有东西，都会一同进行拷贝
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testThirteen() throws IOException {
    FileUtils.copyToDirectory(new File("C:\\Users\\JustryDeng\\Desktop\\abc"),
            new File("C:\\Users\\JustryDeng\\Desktop\\mq\\tmp\\"));
}

• 拷贝URL指向的文件到指定文件(即：下载URL指向的文件)

/**
 * 拷贝URL指向的文件 到 指定文件(即:下载URL指向的文件)
 * 注:如果文件的相关目录不存在，那么会自动创建相关文件夹
 * 注:copyURLToFile还有一个重载方法copyURLToFile(URL source, File destination, int connectionTimeout, int readTimeout)
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testFourteen() throws IOException {
    URL url = new URL("https://avatar.csdn.net/D/8/D/3_justry_deng.jpg");
    FileUtils.copyURLToFile(url, new File("C:\\Users\\JustryDeng\\Desktop\\mq\\tmp\\ds.jpg"));
}

• 清除目录(而不删除它)

/**
 * 清除目录(而不删除它)
 *
 * @date 2019/6/13 19:44
 */
@Test
public void testFive() throws IOException {
    FileUtils.cleanDirectory(new File("C:\\Users\\JustryDeng\\Desktop\\xyz"));
}

• 删除文件夹(及里面的内容)

/**
 * 删除文件夹(及里面的内容)
 *
 * 注:如果删除失败的话，那么会IOException抛出异常
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testFiveteen() throws IOException {
    FileUtils.deleteDirectory(new File("C:\\Users\\JustryDeng\\Desktop\\mq"));
}

• 删除指定的文件或指定的文件夹(及里面的内容)

/**
 * 删除指定的文件 或 指定的文件夹(及里面的内容)
 *
 * 注:如果删除失败的话，那么会IOException抛出异常
 * 注:此方法不会抛出异常，只会返回 删除成功与否(提示:若文件/文件夹不存在，则会被视为删除失败，进而返回false)
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testSixteen() {
    boolean result = FileUtils.deleteQuietly(new File("C:\\Users\\JustryDeng\\Desktop\\mq"));
    System.out.println(result);
}

• 判断指定目录下，是否存在指定的文件、文件夹

/**
 * 判断指定目录下，是否存在 指定的文件、文件夹
 * 注:不仅能看子级的，还能看子孙级别的
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testSeventeen() throws IOException {
    boolean result = FileUtils.directoryContains(new File(BASE_DIR),
                                                 new File(BASE_DIR + "\\z\\tmp\\l.txt"));
    System.out.println(result);
}

• 根据给定的文件，创建其所在的目录

/**
 * 根据给定的文件,创建其所在的目录
 *
 * 注:若父目录也不存在，那么会自动创建
 * 注:还有一个相似的方法:创建给定的文件夹目录FileUtils.forceMkdir
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testEighteen() throws IOException {
    FileUtils.forceMkdirParent(new File("C:\\Users\\JustryDeng\\Desktop\\ppt\\tmp\\mq.pdf"));

}

• 通过工具类获取File

• 查看文件、文件夹的大小

/**
 * 演示一: 通过工具类获取File
 * 演示二: 查看文件、文件夹的大小
 *
 * 注:若父目录也不存在，那么会自动创建
 * 注:还有一个相似的方法:创建给定的文件夹目录FileUtils.forceMkdir
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testNineteen() {
    // 通过工具类获取File
    File file = FileUtils.getFile(new File("C:\\Users\\JustryDeng\\Desktop\\阿里巴巴Java开发手册1.4.0.pdf"));
    // 查看文件、文件夹的大小
    System.out.println(FileUtils.sizeOf(file) + "bytes");
    System.out.println(FileUtils.sizeOf(file) * 1.0 / 1024 / 1024 + "MB");
}

• 根据文件，获得输入流

• 根据文件，获得输出流

• 将文件的内容读入字节数组

• 将文件的内容读入字符串

/**
 * 演示一: 根据文件，获得输入流
 * 演示二: 根据文件，获得输出流
 * 演示三: 将文件的内容读入字节数组
 * 演示四: 将文件的内容读入字符串
 *
 * 注:若父目录也不存在，那么会自动创建
 * 注:还有一个相似的方法:创建给定的文件夹目录FileUtils.forceMkdir
 *
 * TODO 本人这里主要是介绍这些个功能，所以本人这里就没有管是否释放资源； 在实际使用时记得要释放资源
 *
 * @date 2019/6/24 14:19
 */
@Test
@SuppressWarnings("unused")
public void testTwenty() throws IOException {
    // 根据文件，获得输入流
    InputStream is = FileUtils.openInputStream(new File("C:\\Users\\JustryDeng\\Desktop\\阿里巴巴Java开发手册1.4.0.pdf"));
    /*
     * 根据文件，获得输出流(若指定位置下有源文件，那么会覆盖源文件)；
     * 注:此方法还有一个重载方法FileUtils.openOutputStream(final File file, final boolean append)
     *    次二哥参数，控制 是覆盖源文件，还是在源文件后面追加(默认为覆盖)。
     */
    OutputStream os = FileUtils.openOutputStream(new File("C:\\Users\\JustryDeng\\Desktop\\m\\d\\阿里巴巴Java开发手册1.4.0.pdf"));
    // 将文件的内容读入字节数组
    byte[] contentBytes = FileUtils.readFileToByteArray(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"));
    // 将文件的内容读入字符串
    String contentString = FileUtils.readFileToString(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"), StandardCharsets.UTF_8);
}

• 将文件的内容按照行为划分，读取出来

/**
 * 将文件的内容按照行为划分，读取出来
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testTwentyOne() throws IOException {
    List lineStrList = FileUtils.readLines(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"), StandardCharsets.UTF_8);
    for (String lineStr : lineStrList) {
        System.out.println(lineStr);
    }
}

• 向指定文件中写入内容

/**
 * 向指定文件中写入内容
 * 注:若文件不存在(或相关文件夹不存在)，那么会自动创建
 *
 * @date 2019/6/24 14:19
 */
@Test
public void testTwentyTwo() throws IOException {
    File targetFile = new File("C:\\Users\\JustryDeng\\Desktop\\asd\\sdf\\f\\c.txt");
    // 通过最后一个参数控制，是覆盖 还是追加
    // 注意:追加数据时，是直接追加，不会另起一行追加；如果需要换行的话，那么可以使用IOUtils.LINE_SEPARATOR
    FileUtils.writeStringToFile(targetFile, IOUtils.LINE_SEPARATOR + "i am data 咿呀咔咔!", Charset.forName("GBK"), true);
}

IOUtils：

声明：下面示例的只是IOUtils一些相对常用的方法。

• 通过InputStream，获取BufferedInputStream

• 通过OutputStream，获取BufferedOutputStream

• 通过Reader，获取BufferedReader

• 通过Writer，获取BufferedWriter

/**
 * 通过InputStream，获取BufferedInputStream
 * 通过OutputStream，获取BufferedOutputStream
 * 通过Reader，获取BufferedReader
 * 通过Writer，获取BufferedWriter
 *
 * 注:方法使用方式一样，本人这里只演示 过InputStream，获取BufferedInputStream
 *
 *
 * BufferedInputStream buffer(InputStream inputStream)
 * BufferedInputStream buffer(InputStream inputStream, int size)
 *
 * BufferedOutputStream    buffer(OutputStream outputStream)
 * BufferedOutputStream    buffer(OutputStream outputStream, int size)
 *
 * BufferedReader  buffer(Reader reader)
 * BufferedReader  buffer(Reader reader, int size)
 *
 * BufferedWriter  buffer(Writer writer)
 * BufferedWriter  buffer(Writer writer, int size)
 *
 * @date 2019/6/25 10:14
 */
@Test
public void testOne() throws IOException {
    InputStream io = FileUtils.openInputStream(new File("C:\\Users\\JustryDeng\\Desktop\\a.txt"));
    // 通过InputStream获取BufferedInputStream，如果InputStream本人就是BufferedInputStream的话，
    // 那么直接返回；否者创建BufferedInputStream
    // 如果BufferedInputStream是新建的的话，那么其默认buffer尺寸为8192
    BufferedInputStream bufferedInputStreamOne = IOUtils.buffer(io);
    // 通过InputStream获取BufferedInputStream，如果BufferedInputStream是新建的的话，那么设置此buffer的尺寸
    BufferedInputStream bufferedInputStreamTwo = IOUtils.buffer(io, 1024);

}

• 通过CharSequence、String，获取InputStream

• 通过byte[]，获取String

• 通过InputStream、Reader、URL，获取String

• 通过InputStream、Reader，获取BufferedInputStream、BufferedReader

• 通过InputStream、Reader、String、URI、URL、URLConnection，获取byte[]

• 通过InputStream、Reader，获取char[]

/**
 * 演示一：通过CharSequence、String，获取InputStream
 * 演示二：通过byte[]，获取String
 * 演示三：通过InputStream、Reader、URL，获取String
 * 演示四：通过InputStream、Reader，获取BufferedInputStream、BufferedReader
 * 演示五：通过InputStream、Reader、String、URI、URL、URLConnection，获取byte[]
 * 演示六：通过InputStream、Reader，获取char[]
 *
 * static InputStream  toInputStream(CharSequence input)
 * static InputStream  toInputStream(CharSequence, Charset)
 * static InputStream  toInputStream(CharSequence input, Charset encoding)
 * static InputStream  toInputStream(CharSequence input, String encoding)
 * static InputStream  toInputStream(String input)
 * static InputStream  toInputStream(String, Charset)
 * static InputStream  toInputStream(String input, Charset encoding)
 * static InputStream  toInputStream(String input, String encoding)
 *
 * static String   toString(byte[] input)
 * static String   toString(byte[] input, String encoding)
 * static String   toString(InputStream input)
 * static String   toString(InputStream, Charset)
 * static String   toString(InputStream input, Charset encoding)
 * static String   toString(InputStream input, String encoding)
 * static String   toString(Reader input)
 * static String   toString(URI uri)
 * static String   toString(URI, Charset)
 * static String   toString(URI uri, Charset encoding)
 * static String   toString(URI uri, String encoding)
 * static String   toString(URL url)
 * static String   toString(URL, Charset)
 * static String   toString(URL url, Charset encoding)
 * static String   toString(URL url, String encoding)
 *
 * static InputStream  toBufferedInputStream(InputStream input)
 * static InputStream  toBufferedInputStream(InputStream input, int size)
 * static BufferedReader   toBufferedReader(Reader reader)
 * static BufferedReader   toBufferedReader(Reader reader, int size)
 *
 * static byte[]   toByteArray(InputStream input)
 * static byte[]   toByteArray(InputStream input, int size)
 * static byte[]   toByteArray(InputStream input, long size)
 * static byte[]   toByteArray(Reader input)
 * static byte[]   toByteArray(Reader, Charset)
 * static byte[]   toByteArray(Reader input, Charset encoding)
 * static byte[]   toByteArray(Reader input, String encoding)
 * static byte[]   toByteArray(String input)
 * static byte[]   String.getBytes()
 * static byte[]   toByteArray(URI uri)
 * static byte[]   toByteArray(URL url)
 * static byte[]   toByteArray(URLConnection urlConn)
 *
 * static char[]   toCharArray(InputStream is)
 * static char[]   toCharArray(InputStream, Charset)
 * static char[]   toCharArray(InputStream is, Charset encoding)
 * static char[]   toCharArray(InputStream is, String encoding)
 * static char[]   toCharArray(Reader input)
 *
 * @date 2019/6/25 10:14
 */
@Test
public void testTwo() throws IOException {
    // 演示一：通过CharSequence、String，获取InputStream
    InputStream io = IOUtils.toInputStream("我是一只小小小小鸟~嗷！嗷！", Charset.forName("GBK"));

    // 演示二：通过byte[]，获取String
    byte[] bytesTmp = new byte[]{97, 98, 99, 100};
    String strOne = IOUtils.toString(bytesTmp, "UTF-8");
    System.out.println(strOne);

    // 演示三：通过InputStream、Reader、URL，获取String
    String strTwo = IOUtils.toString(io, Charset.forName("GBK"));
    System.out.println(strTwo);

    // 演示四：通过InputStream、Reader，获取BufferedInputStream、BufferedReader
    InputStream isTwo = FileUtils.openInputStream(FileUtils.getFile("C:\\Users\\JustryDeng\\Desktop\\a.txt"));
    InputStream isTmp = IOUtils.toBufferedInputStream(isTwo);
    System.out.println(isTmp);
    Reader readerOne = new FileReader(("C:\\Users\\JustryDeng\\Desktop\\a.txt"));
    BufferedReader brTmp = IOUtils.toBufferedReader(readerOne);
    System.out.println(brTmp);

    // 演示五：通过InputStream、Reader、String、URI、URL、URLConnection，获取byte[]
    FileInputStream fis = new FileInputStream("C:\\Users\\JustryDeng\\Desktop\\a.txt");
    InputStreamReader isr = new InputStreamReader(fis, "GBK");
    byte[] byteData = IOUtils.toByteArray(isr, Charset.forName("GBK"));
    System.out.println(new String(byteData, Charset.forName("GBK")));

    // 演示六：通过InputStream、Reader，char[]
    InputStream ioTwo = IOUtils.toInputStream("我是一只小小小小鸟~嗷！嗷！", Charset.forName("GBK"));
    char[] charData = IOUtils.toCharArray(ioTwo, Charset.forName("GBK"));
    for (char c : charData) {
        System.out.println(c);
    }
}

• 比较两个流的数据是否相等

/**
 * 比较两个流的数据是否相等
 *
 * 相似的方法还有:
 *      boolean contentEquals(InputStream input1, InputStream input2)
 *      boolean contentEquals(Reader input1, Reader input2)
 *      boolean contentEqualsIgnoreEOL(Reader input1, Reader input2)
 * @date 2019/6/25 10:14
 */
@Test
public void testThree() throws IOException {
    InputStream isOne = IOUtils.toInputStream("我是一只小小小小鸟~嗷！嗷！", Charset.forName("GBK"));
    InputStream isTwo = IOUtils.toInputStream("我是一只小小小小鸟~嗷！嗷！", Charset.forName("GBK"));
    boolean result = IOUtils.contentEquals(isOne, isTwo);
    System.out.println(result);
}

• 将输入流的数据，拷贝至输出流

/**
 * 将输入流的数据，拷贝至输出流
 *
 * 相似的方法还有:
 *      copy(InputStream input, OutputStream output)
 *      copy(InputStream input, OutputStream output, int bufferSize)
 *      copy(InputStream, Writer, Charset) instead
 *      copy(InputStream input, Writer output, Charset inputEncoding)
 *      copy(InputStream input, Writer output, String inputEncoding)
 *      copy(Reader, OutputStream, Charset) instead
 *      copy(Reader input, OutputStream output, Charset outputEncoding)
 *      copy(Reader input, OutputStream output, String outputEncoding)
 *      copy(Reader input, Writer output)
 *
 *      copyLarge(InputStream input, OutputStream output)
 *      copyLarge(InputStream input, OutputStream output, byte[] buffer)
 *      copyLarge(InputStream input, OutputStream output, long inputOffset, long length)
 *      copyLarge(InputStream input, OutputStream output, long inputOffset, long length, byte[] buffer)
 *      copyLarge(Reader input, Writer output)
 *      copyLarge(Reader input, Writer output, char[] buffer)
 *      copyLarge(Reader input, Writer output, long inputOffset, long length)
 *      copyLarge(Reader input, Writer output, long inputOffset, long length, char[] buffer)
 * @date 2019/6/25 10:14
 */
@Test
public void testFour() throws IOException {
    InputStream is = IOUtils.toInputStream("我是一只小小小小鸟~嗷！嗷！", Charset.forName("GBK"));
    OutputStream os = FileUtils.openOutputStream(new File("C:\\Users\\JustryDeng\\Desktop\\c.txt"));
    // 复制
     long bytesCount = IOUtils.copy(is, os, 10240);
    // 复制(这个方法其实是对copy(InputStream input, OutputStream output, int bufferSize)的封
    //      装，只是buffer尺寸设置得较大，所以这个方法适合拷贝较大的数据流，比如2G以上)
    // long bytesCount = IOUtils.copyLarge(is, os);
    System.out.println("复制了的字节数：" + bytesCount);
}

• 以行为单元，从输入流中读取数据

/**
 * 以行为单元，从输入流中读取数据
 *
 * 相似的方法还有:
 *      lineIterator(InputStream input, Charset encoding)
 *      lineIterator(InputStream input, String encoding)
 *      lineIterator(Reader reader)
 *
 *      readLines(InputStream input)
 *      readLines(InputStream, Charset) instead
 *      readLines(InputStream input, Charset encoding)
 *      readLines(InputStream input, String encoding)
 *      readLines(Reader input)
 *
 * @date 2019/6/25 11:32
 */
@Test
public void testFive() throws IOException {
    // 示例lineIterator
    InputStream isOne = IOUtils.toInputStream("我是\n一只\n小小小小\n鸟~\n嗷！嗷！", Charset.forName("UTF-8"));
    LineIterator iterator= IOUtils.lineIterator(isOne, Charset.forName("UTF-8"));
    while (iterator.hasNext()) {
        System.out.println(iterator.nextLine());
    }
    // 示例readLines
    InputStream isTwo = IOUtils.toInputStream("这里的\n山路\n十八弯！", Charset.forName("GBK"));
    List list= IOUtils.readLines(isTwo, Charset.forName("GBK"));
    System.out.println(list);
}

• 从流中读取数据至byte[]

/**
 * 从流中读取数据至byte[]
 *
 * 相似的方法还有:
 *      read(InputStream input, byte[] buffer)
 *      read(InputStream input, byte[] buffer, int offset, int length)
 *      read(ReadableByteChannel input, ByteBuffer buffer)
 *      read(Reader input, char[] buffer)
 *      read(Reader input, char[] buffer, int offset, int length)
 *
 *      readFully(InputStream input, byte[] buffer)
 *      readFully(InputStream input, byte[] buffer, int offset, int length)
 *      static byte[]  readFully(InputStream input, int length)
 *      readFully(ReadableByteChannel input, ByteBuffer buffer)
 *      readFully(Reader input, char[] buffer)
 *      readFully(Reader input, char[] buffer, int offset, int length)
 * @date 2019/6/25 11:41
 */
@Test
public void testSix() throws IOException {
    // 示例read
    InputStream isOne = IOUtils.toInputStream("我是\n一只\n小小小小\n鸟~\n嗷！嗷！", Charset.forName("UTF-8"));
    byte[] buffer = new byte[50];
    IOUtils.read(isOne, buffer);
    System.out.println(new String(buffer));

    // 示例readFully
    // 注意:与read不同的是，如果输入流中的字节长度不足的话，readFully会抛出异常！(而read不会)
    InputStream isTwo = IOUtils.toInputStream("我是\n一只\n小小小小\n鸟~\n嗷！嗷！", Charset.forName("UTF-8"));
    byte[] data = IOUtils.readFully(isTwo,40);
    System.out.println(new String(data));
}

• 将数据写入到输出流

/**
 * 将数据写入到输出流
 *
 * 类似的还有：
 *      static void    writeLines(Collection lines, String lineEnding, OutputStream output)
 *      static void    writeLines(Collection, String, OutputStream, Charset)
 *      static void    writeLines(Collection lines, String lineEnding, OutputStream output, Charset encoding)
 *      static void    writeLines(Collection lines, String lineEnding, OutputStream output, String encoding)
 *      static void    writeLines(Collection lines, String lineEnding, Writer writer)
 *
 *      static void    write(byte[] data, OutputStream output)
 *      static void    write(byte[] data, Writer output)
 *      static void    write(byte[], Writer, Charset)
 *      static void    write(byte[] data, Writer output, Charset encoding)
 *      static void    write(byte[] data, Writer output, String encoding)
 *      static void    write(char[] data, OutputStream output)
 *      static void    write(char[], OutputStream, Charset)
 *      static void    write(char[] data, OutputStream output, Charset encoding)
 *      static void    write(char[] data, OutputStream output, String encoding)
 *      static void    write(char[] data, Writer output)
 *      static void    write(CharSequence data, OutputStream output)
 *      static void    write(CharSequence, OutputStream, Charset)
 *      static void    write(CharSequence data, OutputStream output, Charset encoding)
 *      static void    write(CharSequence data, OutputStream output, String encoding)
 *      static void    write(CharSequence data, Writer output)
 *      static void    write(StringBuffer data, OutputStream output)
 *      static void write(CharSequence, OutputStream)
 *      static void    write(StringBuffer data, OutputStream output, String encoding)
 *      static void    write(CharSequence, OutputStream, String)
 *      static void    write(StringBuffer data, Writer output)
 *      static void    write(CharSequence, Writer)
 *      static void    write(String data, OutputStream output)
 *      static void    write(String, OutputStream, Charset)
 *      static void    write(String data, OutputStream output, Charset encoding)
 *      static void    write(String data, OutputStream output, String encoding)
 *      static void    write(String data, Writer output)
 *
 *      static void    writeChunked(byte[] data, OutputStream output)
 *      static void    writeChunked(char[] data, Writer output)

 *
 * @date 2019/6/25 11:57
 */
@Test
public void testSeven() throws IOException {
    // 示例writeLines
    OutputStream osOne = FileUtils.openOutputStream(new File("C:\\Users\\JustryDeng\\Desktop\\c.txt"), true);
    List linesData = new ArrayList<>(8);
    linesData.add(IOUtils.LINE_SEPARATOR);
    linesData.add("邓沙利文");
    linesData.add("亨得帅");
    linesData.add("邓二洋");
    IOUtils.writeLines(linesData, IOUtils.LINE_SEPARATOR, osOne, "GBK");

    // 示例write
    OutputStream osTwo = FileUtils.openOutputStream(new File("C:\\Users\\JustryDeng\\Desktop\\c.txt"), true);
    char[] charData = new char[]{'s', 'w', 'a', 'g', 'g', 'e', 'r', '挺', '好', '的', '!'};
    IOUtils.write(charData, osTwo, "GBK");

    byte[] byteData = (IOUtils.LINE_SEPARATOR + "我是一只小小小小鸟~").getBytes("GBK");
    IOUtils.write(byteData, osTwo);
}

 

笔者建议：更多细节与用法可自行查阅commons-io官方文档，链接见文末。

 

^_^ 如有不当之处，欢迎指正

^_^ 参考链接
              http://commons.apache.o...elease/index.html

^_^ 测试代码托管链接
              https://github.com/JustryDeng/CommonRepository

^_^ 本文已经被收录进《程序员成长笔记(五)》，笔者JustryDeng