commons-io之FileUtils、IOUtils

- 日理万妓 2022-01-07 05:33 650阅读 0赞

**笔者日常：这是笔者来深圳后的第一篇博客~记录一下，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的依赖 ###

<dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.6</version>
    </dependency>

### 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<File> 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<File> 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<File> filesList = FileUtils.listFiles(new File(BASE_DIR ), extensions, true);
        for (File file: filesList) {
            System.out.println(file.getAbsolutePath());
        }
    }

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

### ^\_^ 测试代码托管链接                 [https://github.com/JustryDeng/CommonRepository][https_github.com_JustryDeng_CommonRepository] ###

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

[http_commons.apache.o...elease_index.html]: http://commons.apache.org/proper/commons-io/javadocs/api-release/index.html
[https_github.com_JustryDeng_CommonRepository]: https://github.com/JustryDeng/CommonRepository