commons-io之FileUtils、IOUtils

最新推荐文章于 2024-05-01 10:00:00 发布
最新推荐文章于 2024-05-01 10:00:00 发布
阅读量3.3k 收藏 13
点赞数 1
分类专栏： Java知识大杂烩 文章标签： commons-io FileUtils IOUtils 文件工具类、IO工具类 常用工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/93616705
版权

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

<!-- https://mvnrepository.com/artifact/commons-io/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

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

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

justry_deng
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
commons-io-2.8.0-API文档-中英对照版.zip
06-05
赠送jar包：commons-io-2.8.0.jar； 赠送原API文档：commons-io-2.8.0-javadoc.jar； 赠送源代码：commons-io-2.8.0-sources.jar； 赠送Maven依赖信息文件：commons-io-2.8.0.pom； 包含翻译后的API文档：commons-io...
commons io 文件处理
qq_37792401的博客
12-12 369
FalseFileFilter：过滤所有文件及目录。AndFileFilter：基于AND逻辑运算。NotFileFilter：基于NOT逻辑运算。OrFileFilter： 基于OR逻辑运算。TrueFileFilter：不进行过滤。文件夹过滤创建时间小于7天。文件夹过滤文件包含llp。
org.apache.commons.io——FileUtils学习笔记
weixin_30387663的博客
07-02 1043
FileUtils类的应用 1、写入一个文件； 2、从文件中读取； 3、创建一个文件夹，包括文件夹； 4、复制文件和文件夹； 5、删除文件和文件夹； 6、从URL地址中获取文件； 7、通过文件过滤器和扩展名列出文件和文件夹； 8、比较文件内容； 9、文件最后的修改时间； 10、计算校验和。 一、复制文件或文件夹方法： 示例： 1 public class C...
Spring IOUtils：流式IO操作的得力助手
最新发布
m0_51176516的博客
05-01 251
Spring框架中的IOUtils类是一个实用工具类，它提供了一系列静态方法，用于简化IO（输入/输出）操作。IOUtils类的主要作用是减少代码冗余，提高代码的可读性和可维护性。通过IOUtils类，开发者可以更方便地处理文件、网络流等IO操作。
常用工具类commons-io的学习使用
热门推荐
weixin_53998054的博客
08-02 1万+
commons-io的学习使用
commons-io程序库使用
OceanSky的专栏
10-13 2625
commons-io程序库使用 commons-io库是帮助开发IO功能的实用程序库，主要包括IOUtils工具类、FileUtils工具类、FilenameUtils工具类、EndianUtils工具类、FileSystemUtils工具类； IOUtils:是使用最频繁的工具类，主要提供读、写、复制、关闭流操作 FileUtils:提供基于JDK文件类的操作。包括阅读、写作、复制、比较和...
commons-io
daqi1983的博客
11-10 846
commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类。有两个主要的类FileUtils, IOUtils。
IO常用工具类 commons-io
chy1984的博客
08-11 1696
都是先调用openOutputStream()打开文件，进行写入，再关闭文件；未指定字符集时，默认使用jvm默认字符集，jvm默认字符集由jvm启动时根据操作系统设置的地区、字符集确定。commons-io 是apache开源的io工具类库，封装了很多IO工具类，使用方便。打开文件后，如果已经读取了所有内容，后续再次读取时游标已经在文件尾了，读不到任何内容。copy()、copyLarge() 底层都是调用相同的方法，区别在于。，用 \ 转义字符串中的 \，所以写成 \\，实际返回、输出的是 \。...
apache commons-io
chuyouyinghe的专栏
10-07 779
commons-io 是 Java 文件 IO『第一库』是公认的，它的功能和代码质量都是极佳的，它好到没有人想到再写一个竞品与之竞争，这么干完全是费力不讨好的做法。
commons-io-2.5-API文档-中文版.zip
06-26
赠送jar包：commons-io-2.5.jar； 赠送原API文档：commons-io-2.5-javadoc.jar； 赠送源代码：commons-io-2.5-sources.jar； 赠送Maven依赖信息文件：commons-io-2.5.pom； 包含翻译后的API文档：commons-io-2.5-...
commons-io-1.3.2-API文档-中文版.zip
07-12
赠送jar包：commons-io-1.3.2.jar； 赠送原API文档：commons-io-1.3.2-javadoc.jar； 赠送源代码：commons-io-1.3.2-sources.jar； 赠送Maven依赖信息文件：commons-io-1.3.2.pom； 包含翻译后的API文档：commons-io...
commons-io-2.11.0-API文档-中文版.zip
05-31
赠送jar包：commons-io-2.11.0.jar； 赠送原API文档：commons-io-2.11.0-javadoc.jar； 赠送源代码：commons-io-2.11.0-sources.jar； 赠送Maven依赖信息文件：commons-io-2.11.0.pom； 包含翻译后的API文档：...
开发工具 commons-io-1.3.2
05-31
开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2...
Apache-Commons-File&IOUtils工具类常用方法使用
qq_57404736的博客
10-15 4872
阿帕奇下IO流所需要使用的工具类的常用方法演示
commons-io工具包的基本使用
热爱编程、热爱生活、热爱探索
08-28 2395
在Java中IO操作很常见，原始的码代码会有很多重复操作，过程很烦锁，这就需要诞生一种新技术来减少这种重复的代码操作，让程序员有更多的时间干正真有意义的事情。于是就诞生了commons-io，它是开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率，commons-io工具包提供了很多有关io操作的类。有两个主要的类,。commons-io相关（也可以直接在官网下载）温馨提示.........
commons-io使用笔记
jw233233的专栏
02-11 877
commons-io是一款处理io流的工具，封装了很多处理io流和文件的方法，可以大大简化我们处理io流和操作文件的代码。从common-io的官方使用文档可以看出，它主要分为工具类、尾端类、行迭代器、文件过滤器、文件比较器和扩展流。 一、工具类 工具类包括FileUtils、IOUtils、FilenameUtils和FileSystemUtils，前三者的方法并没有多大的区别，只是操作的对
Java中commons-IO
2401_84024343的博客
04-11 858
总而言之，面试官问来问去，问的那些Redis知识点也就这么多吧，复习的不够到位，知识点掌握不够熟练，所以面试才会卡壳。将这些Redis面试知识解析以及我整理的一些学习笔记分享出来给大家参考学习一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！一个人可以走的很快，但一群人才能走的更远。
【JAVASE】commons-io工具包
Robin的博客
10-08 2015
commons-io提供了一个工具类 org.apache.commons.io.IOUtils，封装了大量IO读写操作的代码。其中有两个常用方法：: 把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以下):把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以上)// 文件路径需要修改,改成自己文件的路径 File file = new File("src/test.txt");
暑期JAVA学习（30）commons - io 框架
xjl243636988的博客
07-24 586
commons - io 框架 一、commons-io概述 二、FileUtils主要方法 三、如何导入commons-io-2.6.jar做开发 （1）需求 （2）步骤 四、FileUtils具体使用 （1）文件复制 （2）文件复制到某个文件夹下 （3）文件夹复制到某个文件夹下 （4）删除文件夹...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值