Java基础(二十二)：File类与IO流

public class FileObjectTest {
    public static void main(String[] args) {
        // 文件路径名
        String pathname = "D:\\aaa\\bbb.txt";
        File file1 = new File(pathname);

        // 通过父路径和子路径字符串
        String parent = "D:\\aaa";
        String child = "bbb.txt";
        File file2 = new File(parent, child);

        // 通过父级File对象和子路径字符串
        File parentDir = new File("D:\\aaa");
        String childFile = "bbb.txt";
        File file3 = new File(parentDir, childFile);
    }
}

URL url = this.getClass().getClassLoader().getResource("");
String filePath = url.getFile();

@Test
public void test1() {
    File file1 = new File("hello.txt");
    System.out.println("文件名称: " + file1.getName());
    System.out.println("文件路径: " + file1.getPath());
    System.out.println("绝对路径: " + file1.getAbsolutePath());
    System.out.println("文件大小: " + file1.length());
    System.out.println("最后修改时间: " + file1.lastModified());
}

文件名称: hello.txt
文件路径: hello.txt
绝对路径: /Users/xuchang/Documents/javaCode/study/code-collection/small-projects/hello.txt
文件大小: 11
最后修改时间: 1710768104275

@Test
public void test2() {
    File file1 = new File("/Users/xuchang/Documents/javaCode/study/code-collection/small-projects/hello.txt");
    System.out.println("文件名称: " + file1.getName());
    System.out.println("文件路径: " + file1.getPath());
    System.out.println("绝对路径: " + file1.getAbsolutePath());
    System.out.println("文件大小: " + file1.length());
    System.out.println("最后修改时间: " + file1.lastModified());
}

文件名称: hello.txt
文件路径: /Users/xuchang/Documents/javaCode/study/code-collection/small-projects/hello.txt
绝对路径: /Users/xuchang/Documents/javaCode/study/code-collection/small-projects/hello.txt
文件大小: 11
最后修改时间: 1710768104275

@Test
public void test3() {
    //public String[] list()
    File file1 = new File("/Users/xuchang/Documents/txt文件");
    String[] fileArr = file1.list();
    for (String s : fileArr) {
        System.out.println(s);
    }

    System.out.println();
    
    //public File[] listFiles()
    File[] files = file1.listFiles();
    for (File f : files) {
        System.out.println(f);
    }
}

环境.txt
.DS_Store
我的文件

/Users/xuchang/Documents/txt文件/环境.txt
/Users/xuchang/Documents/txt文件/.DS_Store
/Users/xuchang/Documents/txt文件/我的文件

@Test
public void test4() {
    // 资源对象-hello.txt必须存在
    File file1 = new File("hello.txt");
    // 目标对象-相对路径下io文件夹必须存在，abc.txt必须不存在
    File file2 = new File("io/abc.txt");

    boolean renameSuccess = file1.renameTo(file2);
    System.out.println(renameSuccess ? "重命名成功" : "重命名失败");
}

@Test
public void test1() throws IOException {
    //1. 创建File类的对象，对应着物理磁盘上的某个文件
    File file = new File("hello.txt");
    //2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中
    FileReader fr = new FileReader(file);
    //3. 通过相关流的方法，读取文件中的数据
//        int data = fr.read(); //每调用一次读取一个字符
//        while (data != -1) {
//            System.out.print((char) data);
//            data = fr.read();
//        }
    int data;
    while ((data = fr.read()) != -1) {
        System.out.print((char) data);
    }

    //4. 关闭相关的流资源，避免出现内存泄漏
    fr.close();
}

@Test
public void test2() {
    FileReader fr = null;
    try {
        //1. 创建File类的对象，对应着物理磁盘上的某个文件
        File file = new File("hello.txt");
        //2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中
        fr = new FileReader(file);
        //3. 通过相关流的方法，读取文件中的数据
        int data;
        while ((data = fr.read()) != -1) {
            System.out.println((char) data);
        }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4. 关闭相关的流资源，避免出现内存泄漏
        try {
            if (fr != null)
                fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Test
public void test3() {
    FileReader fr = null;
    try {
        //1. 创建File类的对象，对应着物理磁盘上的某个文件
        File file = new File("hello.txt");
        //2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中
        fr = new FileReader(file);
        //3. 通过相关流的方法，读取文件中的数据
        char[] cbuf = new char[5];
        /*
         * read(char[] cbuf) : 每次将文件中的数据读入到cbuf数组中，并返回读入到数组中的
         * 字符的个数。
         * */
        int len; //记录每次读入的字符的个数
        while ((len = fr.read(cbuf)) != -1) {
            //处理char[]数组即可
            //错误：
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
            //错误：
//                String str = new String(cbuf);
//                System.out.print(str);
            //正确：
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
            //正确：
            String str = new String(cbuf, 0, len);
            System.out.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4. 关闭相关的流资源，避免出现内存泄漏
        try {
            if (fr != null)
                fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Test
public void test01()throws IOException {
    // 使用文件名称创建流对象
    FileWriter fw = new FileWriter(new File("fw.txt"));
    // 写出数据
    fw.write(97); // 写出第1个字符
    fw.write('b'); // 写出第2个字符
    fw.write('C'); // 写出第3个字符
    fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。

    // 字符串转换为字节数组
    char[] chars = "尚硅谷".toCharArray();
    // 写出字符数组
    fw.write(chars); // 尚硅谷
    // 写出从索引1开始，2个字符。
    fw.write(chars,1,2); // 硅谷

    // 写出字符串
    fw.write("尚硅谷");
        
    //关闭资源
    fw.close();
}

@Test
public void test02(){
    FileWriter fw = null;
    try {
        //1. 创建File的对象
        File file = new File("personinfo.txt");
        //2. 创建FileWriter的对象，将File对象作为参数传递到FileWriter的构造器中
        //如果输出的文件已存在，则会对现有的文件进行覆盖
        fw = new FileWriter(file);
//            fw = new FileWriter(file,false);
        //如果输出的文件已存在，则会在现有的文件末尾写入数据
//            fw = new FileWriter(file,true);

        //3. 调用相关的方法，实现数据的写出操作
        //write(String str) / write(char[] cbuf)
        fw.write("I love you,");
        fw.write("you love him.");
        fw.write("so sad".toCharArray());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4. 关闭资源，避免内存泄漏
        try {
            if (fw != null)
                fw.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public class FWWriteFlush {
    //注意：应该使用try-catch-finally处理异常。这里出于方便阅读代码，使用了throws的方式
    @Test
    public void test() throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();

        // 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

@Test
public void test() throws IOException {
    // 使用文件名称创建流对象
    FileInputStream fis = new FileInputStream("read.txt");
    // 读取数据，返回一个字节
    int read = fis.read();
    System.out.println((char) read);
    read = fis.read();
    System.out.println((char) read);
    read = fis.read();
    System.out.println((char) read);
    read = fis.read();
    System.out.println((char) read);
    read = fis.read();
    System.out.println((char) read);
    // 读取到末尾,返回-1
    read = fis.read();
    System.out.println(read);
    // 关闭资源
    fis.close();
    /*
    文件内容：abcde
    输出结果：
    a
    b
    c
    d
    e
    -1
     */
}

@Test
public void test02()throws IOException{
    // 使用文件名称创建流对象
    FileInputStream fis = new FileInputStream("read.txt");
    // 定义变量，保存数据
    int b;
    // 循环读取
    while ((b = fis.read())!=-1) {
        System.out.println((char)b);
    }
    // 关闭资源
    fis.close();
}

@Test
public void test04()throws IOException{
    // 使用文件名称创建流对象.
    FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
    // 定义变量，作为有效个数
    int len;
    // 定义字节数组，作为装字节数据的容器
    byte[] b = new byte[2];
    // 循环读取
    while (( len= fis.read(b))!=-1) {
        // 每次读取后,把数组的有效字节部分，变成字符串打印
        System.out.println(new String(b,0,len));//  len 每次读取的有效字节个数
    }
    // 关闭资源
    fis.close();
    /*
    输出结果：
    ab
    cd
    e
     */
}

@Test
public void test01() throws IOException {
    // 使用文件名称创建流对象
    FileOutputStream fos = new FileOutputStream("fos.txt");
    // 写出数据
    fos.write(97); // 写出第1个字节
    fos.write(98); // 写出第2个字节
    fos.write(99); // 写出第3个字节
    // 关闭资源
    fos.close();
  /*  输出结果：abc*/
}

@Test
public void test02()throws IOException {
    // 使用文件名称创建流对象
    FileOutputStream fos = new FileOutputStream("fos.txt");
    // 字符串转换为字节数组
    byte[] b = "abcde".getBytes();
    // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
    fos.write(b,2,2);
    // 关闭资源
    fos.close();
}

//这段程序如果多运行几次，每次都会在原来文件末尾追加abcde
@Test
public void test03()throws IOException {
    // 使用文件名称创建流对象
    FileOutputStream fos = new FileOutputStream("fos.txt",true);
    // 字符串转换为字节数组
    byte[] b = "abcde".getBytes();
    fos.write(b);
    // 关闭资源
    fos.close();
}

@Test
public void test05() {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //1. 造文件-造流
        //复制图片：成功
//            fis = new FileInputStream(new File("pony.jpg"));
//            fos = new FileOutputStream(new File("pony_copy1.jpg"));

        //复制文本文件：成功
        fis = new FileInputStream(new File("hello.txt"));
        fos = new FileOutputStream(new File("hello1.txt"));

        //2. 复制操作（读、写）
        byte[] buffer = new byte[1024];
        int len;//每次读入到buffer中字节的个数
        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
//                String str = new String(buffer,0,len);
//                System.out.print(str);
        }
        System.out.println("复制成功");
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        //3. 关闭资源
        try {
            if (fos != null)
                fos.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            if (fis != null)
                fis.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

public void copyFileWithFileStream(String srcPath,String destPath){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //1. 造文件-造流
        fis = new FileInputStream(new File(srcPath));
        fos = new FileOutputStream(new File(destPath));

        //2. 复制操作（读、写）
        byte[] buffer = new byte[100];
        int len;//每次读入到buffer中字节的个数
        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }
        System.out.println("复制成功");
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        //3. 关闭资源
        try {
            if (fos != null)
                fos.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            if (fis != null)
                fis.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public void copyFileWithBufferedStream(String srcPath,String destPath){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try {
        //1. 造文件
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);
        //2. 造流
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);

        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);

        //3. 读写操作
        int len;
        byte[] buffer = new byte[100];
        while ((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
        System.out.println("复制成功");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4. 关闭资源(如果有多个流，我们需要先关闭外面的流，再关闭内部的流)
        try {
            if (bos != null)
                bos.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            if (bis != null)
                bis.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

public class BufferedIOLine {
    @Test
    public void testReadLine()throws IOException {
        // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        // 定义字符串,保存读取的一行文字
        String line;
        // 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.println(line);
        }
        // 释放资源
        br.close();
    }

    @Test
    public void testNewLine()throws IOException{
        // 创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
        // 写出数据
        bw.write("尚");
        // 写出换行
        bw.newLine();
        bw.write("硅");
        bw.newLine();
        bw.write("谷");
        bw.newLine();
        // 释放资源
        bw.close();
    }
}

public class Problem {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
        int data;
        while ((data = fileReader.read()) != -1) {
            System.out.print((char)data);
        }
        fileReader.close();
    }
}

输出结果：
���

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 定义文件路径,文件为gbk编码
        String fileName = "E:\\file_gbk.txt";
        //方式1：
        // 创建流对象,默认UTF8编码
        InputStreamReader isr1 = new InputStreamReader(new FileInputStream(fileName));
        // 定义变量,保存字符
        int charData;
        // 使用默认编码字符流读取,乱码
        while ((charData = isr1.read()) != -1) {
            System.out.print((char)charData); // ��Һ�
        }
        isr1.close();
		
        //方式2：
        // 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(fileName) , "GBK");
        // 使用指定编码字符流读取,正常解析
        while ((charData = isr2.read()) != -1) {
            System.out.print((char)charData);// 大家好
        }
        isr2.close();
    }
}

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 定义文件路径
        String FileName = "E:\\out_utf8.txt";
        // 创建流对象,默认UTF8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
        // 写出数据
        osw.write("你好"); // 保存为6个字节
        osw.close();

        // 定义文件路径
        String FileName2 = "E:\\out_gbk.txt";
        // 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new                     
                                                FileOutputStream(FileName2),"GBK");
        // 写出数据
        osw2.write("你好");// 保存为4个字节
        osw2.close();
    }
}

int age = 300;
char gender = '男';
int energy = 5000;
double price = 75.5;
boolean relive = true;

String name = "巫师";
Student stu = new Student("张三",23,89);

byte readByte()                short readShort()
int readInt()                  long readLong()
float readFloat()              double readDouble()
char readChar()				 boolean readBoolean()					
String readUTF()               void readFully(byte[] b)

public class ReadWriteDataOfAnyType {
    @Test
    public void save() throws IOException {
        String name = "巫师";
        int age = 300;
        char gender = '男';
        int energy = 5000;
        double price = 75.5;
        boolean relive = true;

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("game.dat"));
        oos.writeUTF(name);
        oos.writeInt(age);
        oos.writeChar(gender);
        oos.writeInt(energy);
        oos.writeDouble(price);
        oos.writeBoolean(relive);
        oos.close();
    }
    @Test
    public void reload()throws IOException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("game.dat"));
        String name = ois.readUTF();
        int age = ois.readInt();
        char gender = ois.readChar();
        int energy = ois.readInt();
        double price = ois.readDouble();
        boolean relive = ois.readBoolean();

        System.out.println(name+"," + age + "," + gender + "," + energy + "," + price + "," + relive);

        ois.close();
    }
}

@Data
public class Employee implements Serializable {
    //static final long serialVersionUID = 23234234234L;
    public static String company; //static修饰的类变量，不会被序列化
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
}

public class ReadWriteObject {
    @Test
    public void save() throws IOException {
        Employee.setCompany("尚硅谷");
        Employee e = new Employee("小谷姐姐", "宏福苑", 23);
        // 创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employee.dat"));
        // 写出对象
        oos.writeObject(e);
        // 释放资源
        oos.close();
        System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
    }

    @Test
    public void reload() throws IOException, ClassNotFoundException {
        // 创建反序列化流
        FileInputStream fis = new FileInputStream("employee.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 读取一个对象
        Employee e = (Employee) ois.readObject();
        // 释放资源
        ois.close();
        fis.close();

        System.out.println(e);
    }
}

static final long serialVersionUID = 234242343243L; //它的值由程序员随意指定即可

public class Employee implements Serializable {
    private static final long serialVersionUID = 1324234L; //增加serialVersionUID
    
    //其它结构：略
}

//  你会看到通过对象的Class创建了ObjectStreamClass
// ObjectStreamClass会保存类相关的信息，包括获取serialVersionUID
// 之后也会调用ObjectStreamClass的write方法进行写入
ObjectStreamClass desc = ObjectStreamClass.lookup(cl, true);
...
// 此处代码判断对象的类型是否可以被序列化
// Class
if (obj instanceof Class) {
         writeClass((Class) obj, unshared);
} 
// ObjectStreamClass
else if (obj instanceof ObjectStreamClass) {
         writeClassDesc((ObjectStreamClass) obj, unshared);
} 
// String
else if (obj instanceof String) {
         writeString((String) obj, unshared);
 }
// 数组
 else if (cl.isArray()) {
         writeArray(obj, desc, unshared);
 }
// 枚举
 else if (obj instanceof Enum) {
         writeEnum((Enum<?>) obj, desc, unshared);
} 
// Serializable实现序列化接口
else if (obj instanceof Serializable) {
         writeOrdinaryObject(obj, desc, unshared);
}
// 其他情况都会抛出异常
 else {
         if (extendedDebugInfo) {
                 throw new NotSerializableException(
                        cl.getName() + "\n" + debugInfoStack.toString());
                } else {
                    throw new NotSerializableException(cl.getName());
         }
}

// 写入ObjectOutputStream，此处用到了serialVersionUID
void writeNonProxy(ObjectOutputStream out) throws IOException {
	// 写入类的名称
    out.writeUTF(name);
    // 写入SerialVersionUID
    out.writeLong(getSerialVersionUID());
    // 写入其他标记，这里就直接省略了
	...
	// 开始写入属性
    out.writeShort(fields.length);
    for (int i = 0; i < fields.length; i++) {
        ObjectStreamField f = fields[i];
        out.writeByte(f.getTypeCode());
        out.writeUTF(f.getName());
        if (!f.isPrimitive()) {
            out.writeTypeString(f.getTypeString());
        }
    }
}

private Object readOrdinaryObject(boolean unshared)
        throws IOException
{
    if (bin.readByte() != TC_OBJECT) {
        throw new InternalError();
    }
// 读取序列化中的ObjectStreamClass
    ObjectStreamClass desc = readClassDesc(false);
    ...
// 通过反射，创建对象
    Object obj;
    try {
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        ...
    }
// 判断是否实现了Externalizable接口
    if (desc.isExternalizable()) {
        readExternalData((Externalizable) obj, desc);
    } 
// 我们并没有实现Externalizable接口，会进入到else判断
else {
// 读取序列化的数据
        readSerialData(obj, desc);
    }

// 判断是否自定义了readObject方法，如果有会调用，如果没有直接返回obj
// 此处省略
   ...
    return obj;
}

if (model.serializable == osc.serializable && !cl.isArray() && suid != osc.getSerialVersionUID()) {
       throw new InvalidClassException(osc.name,
                 "local class incompatible: " +
                  "stream classdesc serialVersionUID = " + suid +
                  ", local class serialVersionUID = " +
                   osc.getSerialVersionUID());
}

private void defaultReadFields(Object obj, ObjectStreamClass desc)
        throws IOException
{	
	// 异常检查等操作
	...
// 开始遍历类的属性列表
    ObjectStreamField[] fields = desc.getFields(false);
    Object[] objVals = new Object[desc.getNumObjFields()];
    int numPrimFields = fields.length - objVals.length;
    for (int i = 0; i < objVals.length; i++) {
        ObjectStreamField f = fields[numPrimFields + i];
        // 注意此处会回到最开始的反序列化位置，完成属性值的反序列化
        objVals[i] = readObject0(f.isUnshared());
        if (f.getField() != null) {
            handles.markDependency(objHandle, passHandle);
        }
    }
    // 通过反射进行赋值
    if (obj != null) {
        desc.setObjFieldValues(obj, objVals);
    }
    passHandle = objHandle;
}

public class OtherStreamTest {
    public static void main(String[] args) {
        System.out.println("请输入信息(退出输入e或exit):");
		// 把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = null;
        try {
        	// 读取用户输入的一行数据 --> 阻塞程序
            while ((s = br.readLine()) != null) { 
                if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
                    System.out.println("安全退出!!");
                    break;
                }
                // 将读取到的整行字符串转成大写输出
                System.out.println("-->:" + s.toUpperCase());
                System.out.println("继续输入信息");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close(); // 关闭过滤流时,会自动关闭它包装的底层节点流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 }

请输入信息(退出输入e或exit):
abc
-->:ABC
继续输入信息
1aA
-->:1AA
继续输入信息
exit
安全退出!!

进程已结束,退出代码0

public final static InputStream in = null;
public final static PrintStream out = null;
public final static PrintStream err = null;

public class TestScanner {
    @Test
    public void test01() throws IOException {
        Scanner input = new Scanner(System.in);
        PrintStream ps = new PrintStream("1.txt");
        while(true){
            System.out.print("请输入一个单词：");
            String str = input.nextLine();
            if("stop".equals(str)){
                break;
            }
            ps.println(str);
        }
        input.close();
        ps.close();
    }
    
    @Test
    public void test2() throws IOException {
        Scanner input = new Scanner(new FileInputStream("1.txt"));
        while(input.hasNextLine()){
            String str = input.nextLine();
            System.out.println(str);
        }
        input.close();
    }
}

- 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
- 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。

public class Test01 {
    public static void main(String[] args)throws Exception {
        //- 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
        IOUtils.copy(new FileInputStream("E:\\Idea\\io\\1.jpg"),new FileOutputStream("E:\\Idea\\io\\file\\柳岩.jpg"));
        //- 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。
       /* FileWriter fw = null;
        try {
            fw = new FileWriter("day21\\io\\writer.txt");
            fw.write("hahah");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
           IOUtils.closeQuietly(fw);
        }*/
    }
}

- 静态方法：void copyDirectoryToDirectory(File src,File dest)：整个目录的复制，自动进行递归遍历
          参数:
          src:要复制的文件夹路径
          dest:要将文件夹粘贴到哪里去
             
- 静态方法：void writeStringToFile(File file,String content)：将内容content写入到file中
- 静态方法：String readFileToString(File file)：读取文件内容，并返回一个String
- 静态方法：void copyFile(File srcFile,File destFile)：文件复制

public class Test02 {
    public static void main(String[] args) {
        try {
            //- 静态方法：void copyDirectoryToDirectory(File src,File dest);
            FileUtils.copyDirectoryToDirectory(new File("E:\\Idea\\io\\aa"),new File("E:\\Idea\\io\\file"));


            //- 静态方法：writeStringToFile(File file,String str)
            FileUtils.writeStringToFile(new File("day21\\io\\commons.txt"),"柳岩你好");

            //- 静态方法：String readFileToString(File file)
            String s = FileUtils.readFileToString(new File("day21\\io\\commons.txt"));
            System.out.println(s);
            //- 静态方法：void copyFile(File srcFile,File destFile)
            FileUtils.copyFile(new File("io\\yangm.png"),new File("io\\yangm2.png"));
            System.out.println("复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}