commons-io之FileUtils、IOUtils

原文：https://blog.csdn.net/justry_deng/article/details/93616705

commons-io简单说明：
Common IO 是一个工具库，用来帮助开发IO功能 它包括6个主要部分：

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

输入：InputStream 和 Reader 实现。

输出：OutputStream 和 Writer 实现。

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

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

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

相对比较常用的有两个工具类：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);
}

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