IO流的使用

Made丨pool

已于 2022-03-21 17:28:21 修改

阅读量726

点赞数 1

分类专栏： JavaSE 文章标签： java

于 2022-03-20 21:57:47 首次发布

本文链接：https://blog.csdn.net/qq_44358876/article/details/123622698

版权

JavaSE 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

第一章 File

1 File理解

文件和目录路径名的抽象表示
java.io.File

2 构造方法

2.1 语法

File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File(String pathname，String child)从父路径名字符串和子路径名字符串创建的File实例
File(File pathname，String child)从父抽象路径名和子路径名字符串创建的File实例
File(URI uri) 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例

2.2 代码

public class Class001_File {
    public static void main(String[] args) {
        //File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
        File file1 = new File("F://");//表示路径的字符串中，路径的分隔符可以使用//,/,\\但是在系统目录中默认使用\表示路径分离
        File file2 = new File("F://AAA/text.txt");
        File file3 = new File("text.txt");

        //File(String pathname，String child)从父路径名字符串和子路径名字符串创建的File实例
        File file4 = new File("F://AAA","text.txt");
        //File(File pathname，String child)从父抽象路径名和子路径名字符串创建的File实例
        File file5 = new File(file1,"AAA/text.txt");
        System.out.println(file1);
        System.out.println(file2);
        System.out.println(file3);
        System.out.println(file4);
        System.out.println(file5);

        System.out.println(file5.equals(file2));
    }
}

3 方法

3.1 语法

boolean setReadOnly() 标记此抽象路径名指定的文件或目录，以便仅允许读取操作
boolean canWriter() 测试应用程序是否可以修改此路径名表示的文件
boolean createNewFile() 当且仅当具有此名称的文件尚不存在时，以原子方式创建由此抽象路径名命名的新空文件。注：不能创建文件夹只能创建文件
delete可以删除文件和不包含子类文件的文件夹
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
File getAbsoluteFile() 返回此抽象路径名的绝对形式。
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
long getFreeSpace() 通过此抽象路径名返回分区 named中未分配的字节数。
long getTotalSpace() 通过此抽象路径名返回分区 named的大小。
String getName() 返回此抽象路径名表示的文件或目录的名称。
String getParent() 返回此抽象路径名父项的路径名字符串，如果此路径名未指定父目录，则返回 null 。
File getParentFile() 返回此抽象路径名父项的抽象路径名，如果此路径名未指定父目录，则返回 null 。
boolean isAbsolute() 测试此抽象路径名是否为绝对路径。
boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
boolean isHidden() 测试此抽象路径名指定的文件是否为隐藏文件。
long lastModified() 返回上次修改此抽象路径名表示的文件的时间。
long length() 返回此抽象路径名表示的文件的长度。
String[] list() 返回一个字符串数组，用于命名此抽象路径名表示的目录中的文件和目录
File[] listFiles() 返回一个抽象路径名数组，表示此抽象路径名表示的目录中的文件。
boolean mkdir() 创建此抽象路径名指定的目录。
boolean mkdirs() 创建此抽象路径名指定的目录，包括任何必需但不存在的父目录。
boolean renameTo(File dest) 重命名此抽象路径名表示的文件。

3.2 代码

public class Class002_File {
    public static void main(String[] args) throws IOException {
        File file1 = new File("F://text.txt");
        File file2 = new File("F://HaHa/text.txt");
        File file3 = new File("text.txt");
        File file4 = new File("F://");

        //boolean setReadOnly() 标记此抽象路径名指定的文件或目录，以便仅允许读取操作
        //System.out.println(file1.setReadOnly());

        //boolean canWriter() 测试应用程序是否可以修改此路径名表示的文件
        System.out.println(file1.canWrite());

        //boolean createNewFile() 当且仅当具有此名称的文件尚不存在时，以原子方式创建由此抽象路径名命名的新空文件。
        //注：不能创建文件夹只能创建文件
        System.out.println(file1.createNewFile());
        //System.out.println(file2.createNewFile());//异常文件夹不存在
        System.out.println(file3.createNewFile());//默认创建在当前项目下
        //delete可以删除文件和不包含子类文件的文件夹
        //System.out.println(file1.delete());
        //boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
        System.out.println(file1.exists());

        //File getAbsoluteFile() 返回此抽象路径名的绝对形式。
        //String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
        System.out.println(file3.getAbsoluteFile());
        System.out.println(file3.getAbsolutePath());

        //long getFreeSpace() 通过此抽象路径名返回分区 named中未分配的字节数。
        System.out.println(file4.getFreeSpace());
        //long getTotalSpace() 通过此抽象路径名返回分区 named的大小。
        System.out.println(file4.getTotalSpace());

        //String getName() 返回此抽象路径名表示的文件或目录的名称。
        System.out.println(file1.getName());

        //String getParent() 返回此抽象路径名父项的路径名字符串，如果此路径名未指定父目录，则返回 null 。
        //File getParentFile() 返回此抽象路径名父项的抽象路径名，如果此路径名未指定父目录，则返回 null 。
        System.out.println(file2.getParent());
        System.out.println(file2.getParentFile());

        //boolean isAbsolute() 测试此抽象路径名是否为绝对路径。
        //boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
        //boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
        //boolean isHidden() 测试此抽象路径名指定的文件是否为隐藏文件。
        System.out.println(file1.isDirectory());

        //long lastModified() 返回上次修改此抽象路径名表示的文件的时间。
        System.out.println(new Date(new File("F://text.txt").lastModified()));
        System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new File("F://text.txt").lastModified()));

        //long length() 返回此抽象路径名表示的文件的长度。
        System.out.println(new File("F://text.txt").length());

        //String[] list() 返回一个字符串数组，用于命名此抽象路径名表示的目录中的文件和目录
        System.out.println(Arrays.toString(new File("F://PythonTest").list()));
        //File[] listFiles() 返回一个抽象路径名数组，表示此抽象路径名表示的目录中的文件。
        System.out.println(Arrays.toString(new File("F://PythonTest").listFiles()));

        //boolean mkdir() 创建此抽象路径名指定的目录。
        System.out.println(new File("F://ccc").mkdir());
        //boolean mkdirs() 创建此抽象路径名指定的目录，包括任何必需但不存在的父目录。
        System.out.println(new File("F://ccc/hehe/text.txt").mkdirs());
        System.out.println(new File("F://ccc/hehee/text.txt").getParentFile().mkdirs());

        //boolean renameTo(File dest) 重命名此抽象路径名表示的文件。
        System.out.println(file1.renameTo(new File("F://haha.txt")));

    }
}

第二章 io流分类

1 IO流理解

IO流: 数据的读入写出,文件的上传下载
流: 一连串流动的数据,以先入先出的方式进行传输–>流就是管道
数据源---->io---->目的地
数据源 : 数据的来源
目的地 : 数据流向的位置

2 流的分类

操作单元分:
字节流 : 万能流 ****
字符流 : 纯文本内容
流向分: 以程序为中心
输入流
输出流
功能分:
节点流 : 真实能做读入写出的
功能流 : 增强节点流的功能,提高节点流的性能
流之间的分类是相辅相成的，java.io包

第三章字节输入流

1 理解

InputStream 字节输入流中最上层父类
文件流 : FileInputStream 文件字节输入流->节点流字节流输入流
操作文件,数据源为文件,使用文件字节输入流
字节数组流 : ByteArrayInputStream 字节数组输入流 ->节点流字节流输入流
操作字节数组,数据源是字节输入,使用字节数组输入流

2 语法

FileInputStream(File file) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的 File对象 file命名。
读入 int read() 每次读入一个字节数,返回读入到的字节,读不到返回-1
提高效率,每次读入一车(字节数组)的数据，int read(byte[])
byte[] readAllBytes() 从输入流中读取所有剩余字节。

3 代码操作

public class Class001_IO {
    public static void main(String[] args) throws IOException {
        File src = new File("D://test.txt");
        //FileInputStream(File file) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的 File对象 file命名。
        InputStream is = new FileInputStream(src);

        //读入 int read() 每次读入一个字节数,返回读入到的字节,读不到返回-1
        /*int num = is.read();
        System.out.println((char)num);
        System.out.println((char)(is.read()));
        System.out.println((char)(is.read()));
        System.out.println(is.read());*/

        //循环读入
        /*int num = -1; //记录每次读到的字节
        while((num=is.read())!=-1){
            System.out.println((char)num);
        }*/

        //提高效率,每次读入一车(字节数组)的数据
        //byte[] car = new byte[1024];
        //int read(byte[]) 每次读入一个字节数组的数据,返回读入到字节数组中数据的个数,没有读到返回-1
        //int len = is.read(car);
        //System.out.println(new String(car,0,len));

        //当内容比较多,需要重复读入,每次读入一个字节数组中的数据
        /*byte[] car = new byte[2];
        int len = -1; //记录每次读入到数组中数据的个数
        while((len = is.read(car))!=-1){
            System.out.println(new String(car,0,len));
        }*/

        //byte[] readAllBytes() 从输入流中读取所有剩余字节。
        byte[] arr = is.readAllBytes();
        System.out.println(new String(arr));

        //关闭
        is.close();
    }
}

第四章字节输出流

1 理解

OutputStream 字节流输出流
FileOutputStream 文件字节输出流 -> 节点流目的地为文件
ByteArrayOutputStream 字节数组输出流 -> 节点流目的地为字节数组
注意: 在输出流写出的时候,如果目的地文件不存在,系统会自动创建目的地文件,如果目的地文件所在路径不存在,抛出异常java.io.FileNotFoundException:(系统找不到指定的路径。)

2 步骤

构建流,指定目的地
写出
刷出
关闭

3 代码

public class Class002_IO {
    public static void main(String[] args) throws IOException {
        //1.构建流,指定目的地
        //FileOutputStream(String name)
        //OutputStream os = new FileOutputStream("D://test.txt");  //默认覆盖原文件中内容
        OutputStream os = new FileOutputStream("D://BBB/test2.txt",true);  //boolean参数->true为追加  false为覆盖

        //2.写出
        os.write(97);

        byte[] arr = "你好再见".getBytes();

        os.write(arr);

        //3.刷出
        os.flush();

        //4.关闭
        os.close();
    }
}

第四章文件拷贝

1 字节流实现文件拷贝

1.1 过程

数据源–>输入流–>程序–>输出流–>目的地

1.2 步骤

1.构建流(输入流输出流)
2.读入写出
3.刷出
4.关闭 (后打开的先关闭)

1.3 代码

public class Class003_CopyFile {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {
            // 1.构建流(输入流  输出流)
            is = new FileInputStream("D://test.txt");
            os = new FileOutputStream("D://DDD/test.txt");
            // 2.读入写出
            byte[] car = new byte[1024];
            int len = -1; //记录每次读入到字节数组中数据的个数
            while((len = is.read(car))!=-1){
                os.write(car,0,len);
            }
            // 3.刷出
            os.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关闭
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2 字符流实现文件拷贝

2.1 理解

字符流 (纯文本数据)
Reader 字符输入流
- FileReader 文件字符输入流 ->节点流
Writer 字符输出流
- FileWriter 文件字符输出流 ->节点流
通过字符流实现文件拷贝

2.2 步骤

构建流(输入,输出)
读写
- 读入 int read() 每次读入一个字符数据
- 读入 int read(char[] cbuf) 将字符读入数组。返回读取的字符数，如果已到达流的末尾，则返回-1
- void write(char[] cbuf) 写一个字符数组。
- void write(char[] cbuf, int off, int len) 写一个字符数组的一部分。
- void write(int c) 写一个字符。
- void write(String str) 写一个字符串。
- void write(String str, int off, int len) 写一个字符串的一部分。
刷出
关闭

2.3 代码

public class Class001_CopyFile {
    public static void main(String[] args) throws IOException {
        //1.构建流(输入,输出)
        Reader rd = new FileReader("D://test.txt");
        Writer rt = new FileWriter("D://dest.txt");
        //2.读写
        //读入 int read() 每次读入一个字符数据
        //读入 int read(char[] cbuf) 将字符读入数组。返回读取的字符数，如果已到达流的末尾，则返回-1
        char[] car = new char[1024];
        int len = -1; //记录每次读入到数组中数据的个数
        while((len=rd.read(car))!=-1){
            //void write(char[] cbuf) 写一个字符数组。
            //void write(char[] cbuf, int off, int len) 写一个字符数组的一部分。
            //void write(int c) 写一个字符。
            //void write(String str) 写一个字符串。
            //void write(String str, int off, int len) 写一个字符串的一部分。
            rt.write(car,0,len);
        }
        //3.刷出
        rt.flush();
        //4.关闭
        rt.close();
        rd.close();
    }
}

第五章功能流

使用:包裹节点流使用
缓冲流 Buffered : 加快节点流的读写效率

5.1 字节缓冲流

5.1.1 理解

字节输入缓冲流 BufferedInputStream
字节输出缓冲流 BufferedOutputStream
无新增方法,可以发生多态

5.1.2 代码

public class Class001_BufferedInputStream {
    public static void main(String[] args) throws IOException {
        //1.构建流
        InputStream is = new BufferedInputStream(new FileInputStream("D://test.txt"));
        OutputStream os = new BufferedOutputStream(new FileOutputStream("D://test1.txt"));

        //2.读入写出
        byte[] car = new byte[1024];
        int len = -1;
        while((len = is.read(car))!=-1){
            os.write(car,0,len);
        }

        //3.刷出
        os.flush();

        //4.关闭
        os.close();
        is.close();
    }
}

5.2 字符缓冲流

5.2.1 理解

字符输入缓冲流 BufferedReader
- 新增功能: String readLine() 读一行文字。
字符输出缓冲流 BufferedWriter
- 新增功能: void newLine() 写一个行分隔符。
存在新增功能,不能发生多态

5.1.2 代码

public class Class002_BufferedReader {
    public static void main(String[] args) throws IOException {
        //1.构建流(输入,输出)
        BufferedReader rd = new BufferedReader(new FileReader("D://test.txt"));
        BufferedWriter rt = new BufferedWriter(new FileWriter("D://dest.txt"));
        //2.读写
        String msg = null;
        while((msg=rd.readLine())!=null){
            rt.write(msg);
            //rt.newLine(); //换行符
        }
        //3.刷出
        rt.flush();
        //4.关闭
        rt.close();
        rd.close();
    }
}

5.3 Date流

5.3.1 理解

Data流 | 基本数据类型流 : 读写数据+保留数据类型->基本数据类型|字符串
- 是字节流的功能流
DataInputStream Data输入流
新增功能 : readXxx()
DataOuutputStream Data输出流
- 新增功能 : writeXxx()
注意: 读入与写出的顺序保持一致
读入数据的时候必须从源文件中读入,否则抛出异常 java.io.EOFException
字节流的功能流

5.3.2 代码

public class Class003_DataInputStream {
    public static void main(String[] args) throws IOException {
		write("F://test1.txt");
        read("F://test1.txt");
    }

    //写出
    public static void write(String path) throws IOException {
        //1.构建输出流
        DataOutputStream os = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
        //2.准备数据
        int i = 100;
        char ch = 'a';
        boolean flag = false;
        String str = "哈哈";

        //3.写出
        os.writeInt(i);
        os.writeChar(ch);
        os.writeBoolean(flag);
        os.writeUTF(str);

        //4.刷出
        os.flush();

        //5.关闭
        os.close();
    }


    //读入
    public static void read(String path) throws IOException {
        //1.构建输入流
        DataInputStream is = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));

        //2.读入
        int i = is.readInt();
        char ch = is.readChar();
        boolean flag = is.readBoolean();
        String msg = is.readUTF();
        //3.处理数据
        System.out.println(i);
        System.out.println(ch);
        System.out.println(flag);
        System.out.println(msg);

        //4.关闭
        is.close();
    }
}

第六章 object与系列化

1 Object流|对象流|引用数据类型流

字节流的功能流
ObjectInputStream 反序列化输入流
- 新增方法 Object readObject() 从ObjectInputStream中读取一个对象。等等
ObjectOutputStream 序列化输出流
- 新增方法 void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

2 序列化

2.1理解

序列化: 将对象数据转为可存储或者可传输的状态的过程
不是所有类型的数据都能序列化 java.io.Serializable
如果写出的对象类型没有实现序列化接口,会遇到运行时异常java.io.NotSerializableException
序列化与反序列化顺序保持一致
不是所有的属性都需要序列化 transient
static的成员不会被序列化
如果父类实现类序列化接口,子类所有内容都可以进行序列化
子类实现了序列化接口,只能序列化子类独有的内容

2.2 序列号

序列号: 当实现了序列化的类型默认存在一个序列号
当类中的成员发生改变,序列号默认会重新生成
作用: 使用序列号可以实现检查前后版本不一致问题
解决不同版本的兼容问题: 手动设置序列号

2.3 快捷键

通过快捷键生成序列号:
1.类型必须实现了序列化接口
2.Setting中进行配置
3.双击类名alt+enter,自动生成序列号

3 代码

public class Class004_Obect {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //testWrite("D://heihei.txt");
        testRead("D://heihei.txt");
    }

    public static void testRead(String path) throws IOException, ClassNotFoundException {
        //1.构建输入流
        ObjectInputStream is = new ObjectInputStream(new FileInputStream(path));
        //2.读入数据
        Person p = (Person) is.readObject();
        int[] arr = (int[]) is.readObject();
        //3.处理数据
        System.out.println(p);
        System.out.println(Arrays.toString(arr));

        //4.关闭
        is.close();
    }

    //序列化输出
    public static void testWrite(String path) throws IOException {
        //1.定义输出流
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(path));
        //2.准备数据
        Person p = new Person("张三",18);
        p.a = 10;
        int[] arr = {1,2,3,4,5};
        //3.写出
        os.writeObject(p);
        os.writeObject(arr);

        //4.刷出
        os.flush();

        //5.关闭
        os.close();

        p.a = 100;
    }
}

第七章 Commons-io

1 理解

CommonsIO 是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写文件,url源代码等。
是一个第三方的开源组件

2 使用步骤

使用第三方组件的步骤:
1.对应官网中下载源码 jar
2.在项目下新建一个文件夹目录lib,lib下存放以后项目所依赖的所有jar包
3.选中jar包,右键add as lib…
4.在项目下对应类中进行使用

在这里插入图片描述

3 commons-io 的使用

3.1. IO工具类IOUtils

IOUtils.copy(InputStream input, OutputStream output) // 此方法有多个重载方法，满足不同的输入输出流
// 这个方法适合拷贝较大的数据流，比如2G以上
IOUtils.copyLarge(Reader input, Writer output) // 默认会用1024*4的buffer来读取
IOUtils.toInputStream(String input, String encoding) // 通过文本获取输入流，可以指定编码格式
IOUtils.toBufferedInputStream(InputStream input) // 获取一个缓冲输入流，默认缓冲大小1KB，也可以指定缓冲大小
IOUtils.toBufferedReader(Reader reader) // 获取一个字符缓冲流，可指定缓冲大小

3.2. IO 工具类 FilenameUtils

这个工具类是用来处理文件名（文件路径）的，可以轻松解决不同操作系统文件名称规范不同的问题，里面的方法都是静态的，直接用类进行调用
FilenameUtils.getBaseName(String filename) // 去除目录和后缀后的文件名
FilenameUtils.getExtension(String filename) // 获取文件的后缀
FilenameUtils.getName(String filename) // 获取文件名
FilenameUtils.getPath(String filename) // 去除盘符后的路径
FilenameUtils.getPrefix(String filename) // 盘符
isExtension(String fileName, String text) // 判断fileName是否是text后缀名

3.3. IO 工具类 FileUtils

提供文件操作，如移动文件、读取文件、检查文件是否存在等的方法
复制文件夹
- FileUtils.copyDirectory(File srcDir, File destDir) // 复制文件夹（文件夹里面的文件内容
  也会复制）
- FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter) // 复制文件夹，
  带有文件过滤功能
- FileUtils.copyDirectoryToDirectory(File srcDir, File destDir) // 以子目录的形式将文件
  夹复制到到另一个文件夹下
复制文件
- FileUtils.copyFile(File srcFile, File destFile) // 复制文件
- FileUtils.copyFileToDirectory(File srcFile, File destDir) // 复制文件到一个指定的目录
把字符串写入文件
- FileUtils.writeStringToFile(File file, String data, String encoding) // 字符串以指定的编码写到文件
- FileUtils.writeStringToFile(File file, String data, String encoding, booleanappend) // 指定知否追加
字节数组写入文件
FileUtils.writeByteArrayToFile(File file, byte[] data) // 系列方法，可以指定追加，偏移量等
文件移动
FileUtils.moveFile(File srcFile, File destFile) // 移动文件
删除文件夹
FileUtils.deleteDirectory(File directory) // 删除文件夹，包括文件夹和文件夹里面所有的文件

3.4. FileSystemUtils的使用

仅有这一个方法，及其重载方法 FileSystemUtils.freeSpaceKb() throws IOException

4 代码

public class Class001_CommonsIO {
    public static void main(String[] args) throws IOException {
        //#### IO工具类IOUtils
        //`IOUtils.copy(InputStream input, OutputStream output) `// 此方法有多个重载方法，满足不同的输入输出流
        IOUtils.copy(new FileInputStream("D://test.txt"),new FileOutputStream("D://xixi.txt"));

        //IO 工具类 FilenameUtils
        //`FilenameUtils.getBaseName(String filename)` // 去除目录和后缀后的文件名
        System.out.println(FilenameUtils.getBaseName("D://test.txt"));
        //`FilenameUtils.getExtension(String filename)` // 获取文件的后缀
        System.out.println(FilenameUtils.getExtension("D://logo.png"));
        //`isExtension(String fileName, String text) `// 判断fileName是否是text后缀名
        System.out.println(FilenameUtils.isExtension("D://logo.jpg","png"));

        //IO 工具类 FileUtils
        //`FileUtils.copyFile(File srcFile, File destFile)` // 复制文件
        FileUtils.copyFile(new File("D://test.txt"), FileUtils.getFile("D://hehe.txt"));

        //`FileUtils.copyFileToDirectory(File srcFile, File destDir)` // 复制文件到一个指定的目录
        FileUtils.copyFileToDirectory(new File("D://test.txt"), new File("D://eee")); //目标路径不存在,也可以帮助创建

        //`FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)`// 指定知否追加
        FileUtils.writeStringToFile(new File("D://test.txt"), "\r\nwangwuwuwuwuwuwuwu", "UTF-8",true);
        //`FileUtils.deleteDirectory(File directory)` // 删除文件夹，包括文件夹和文件夹里面所有的文件
        FileUtils.deleteDirectory(new File("D://DDD"));

        //`FileUtils.copyDirectory(File srcDir, File destDir)` // 复制文件夹（文件夹里面的文件内容也会复制）
        FileUtils.copyDirectory(new File("D://AAA"), new File("D://BBB"));

        //`FileUtils.copyDirectoryToDirectory(File srcDir, File destDir)` // 以子目录的形式将文件夹复制到到另一个文件夹下
        FileUtils.copyDirectoryToDirectory(new File("D://AAA"), new File("D://BBB"));

        //`FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter)` // 复制文件夹，带有文件过滤功能
        FileUtils.copyDirectory(new File("D://AAA"), new File("D://HAHA"), FileFilterUtils.fileFileFilter());
    }
}

Made丨pool

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流的使用

第一章 File1 File理解文件和目录路径名的抽象表示java.io.File2 构造方法2.1 语法File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的File实例File(String pathname，String child)从父路径名字符串和子路径名字符串创建的File实例File(File pathname，String child)从父抽象路径名和子路径名字符串创建的File实例File(URI uri) 通过将给定的 fil
复制链接

扫一扫