import java.io.File;
import java.util.ArrayList;

public class Main {
    public static void main(String[] ages) {
        // 创建存放查找结果的文件列表
        ArrayList<String> fileList = new ArrayList<>();

        // 调用方法
        // - 传入查找目录范围（File对象）
        // - 查找的目标文件名
        // - 保存查找到的文件列表
        searchFile(new File("/home/magictable/Projec/"), "Main.java", fileList);

        // 判断文件列表中的最新数据是否为0
        if (fileList.size() == 0) {
            System.out.println("未找到目标文件");
        }
        // 输出文件列表中存储的最新数据
        for (int i=0; i < fileList.size(); i++) {
            // 格式化输出结果
            System.out.println("结果"+ (i+1) + "：" + fileList.get(i));
        }

    }

    /**
     * 搜索指定目录范围下的目标文件
     * @param dir 查找的目录范围（File文件）
     * @param fileName 查找的目标文件名
     * @param fileList 保存查找到的文件列表
     */
    public static void searchFile(File dir, String fileName, ArrayList<String> fileList) {
        // 判断输入的`dir`文件夹：
        // - 是否不存在
        // - 是否是一个文件
        // - 是否是空目录
        if (!dir.exists() || dir.isFile() || dir == null) {
            return;
        }

        // 获取`dir`目录下的全部一级文件对象
        File[] fileArray = dir.listFiles();
        // 判断文件夹大小是否为“0字节”（用于判断是否拥有该文件夹的权限）
        // 是否是空的“文件夹”
        if (fileArray.length > 0  && fileArray != null) {
            // 获取该目录下的全部一级文件对象
            for (File f : fileArray) {
                // 判断文件是否是文件
                if (f.isFile()) {
                    // 判断文件是否是我们要找的
                    if (f.getName().equals(fileName)) {
                        // 将当前文件对象的绝对路径保存到文件列表中
                        fileList.add(f.getAbsolutePath());
                    }
                }
                else {   // 当前文件是一个文件夹
                    // 调用该方法进行重复查找过程，递归算法
                    searchFile(f, fileName, fileList);
                }
            }
        }

    }


}

try {
    // 实例化File对象，添加要操作的文件
    File file = new File("/home/abc.text");

    // 实例化字节输入流对象，传入需要读取的File文件对象
 FileInputStream inputFile = new FileInputStream(file);      
 
    // 类似缓存区，一批次能读取多少字节
 byte[] byteData = new byte[3];
    // 记录当前批次读取了多少字节
 int len;
 while ((len = inputFile.read(byteData)) != -1) {
        // 读取的内容是根据data读取多少字节，就输出到多少字节。
        // 该步骤是正在“解码”操作，即将二进制文件转换为字符串数据
        String fileData = new String(byteData, 0, len);
        // 在控制台输出显示
        String.out.print(fileData);
 }
 // 释放输出流对象
 inputFile.close();

} catch (IOException e) {
 System.out.println("文件操作报错：" + e.getMessage());
}

try {
    // 实例化File对象，添加要操作的文件
    File file = new File("/home/abc.text");

    // 实例化字节输出流对象，传入需要写入的File文件对象
 FileOutputStream outputFile = new FileOutputStream(file);
 
    // 需要写入文件的数据
    String data = "你好，世界。";

    // 将数据进行“编码”操作，即将字符串数据转换为二进制文件
    byte[] byteData = data.getBytes();

    // 将编码后的数据，通过字节输出流对象，写入到文件
    outputFile.write(byteData);

    // 释放输出流对象
    outputFile.close();

} catch (IOException e) {
 System.out.println("文件复制失败：" + e.getMessage());
}

// 实例化File对象，添加要操作的文件
File file = new File("/home/file.text");

try (
        // 实例化字符输入流，添加要读取的File对象
        FileReader readerFile = new FileReader(file);
) {

    // 创建临时存储空间，存储读取出的字符
    char[] charArray = new char[1024];
    // 记住当批次读取了多少字符
    int len;
    while ((len=readerFile.read(charArray)) != -1) {
        // 将字符列表“解码”成字符串
        String data = new String(charArray, 0, len);
        // 将结果输出到控制台
        System.out.print(data);
    }

} catch (IOException e) {
 System.out.println("文件复制失败：" + e.getMessage());
}

// 实例化File对象，添加要操作的文件
File file = new File("/home/file.text");

try (
        // 实例化字符输出流对象，传入需要写入的File文件对象
        FileWriter fileWriter = new FileWriter(file);
) {
    
    // 需要写入文件的数据
    String data = "你好，世界。";

    // 将数据通过字符输出流对象，写入到File文件
    fileWriter.write(data);

} catch (IOException e) {
 System.out.println("文件写入失败：" + e.getMessage());
}

import java.io.IOException;  // IO异常处理类
import java.io.File;         // File文件对象
import java.io.FileInputStream;   // 文本字节输入流
import java.io.FileOutputStream;  // 文本字节输出流
import java.io.BufferedInputStream;   // 文本字节缓冲输入流
import java.io.BufferedOutputStream;  // 文本字节缓冲输出流


public class Main {
    public static void main(String[] ages) {
        // 实例化File对象，添加要读取的文件
        File file = new File("/home/file.text");
        // 实例化File对象，添加要复制写入的文件
        File fileCopy = new File("/home/fileCopy.text");

        try (
                // 实例化字节输入流对象，添加要读取的File对象
                FileInputStream is = new FileInputStream(file);
                // 实例化字节缓冲输入流对象，包装原始字节输入流，即添加缓冲区
                BufferedInputStream bis = new BufferedInputStream(is);

                // 实例化字节输出流对象，添加要写入的File对象
                FileOutputStream of = new FileOutputStream(fileCopy);
                // 实例化字节缓冲输出流对象，包装原始字节输出流，即添加缓冲区
                BufferedOutputStream bos = new BufferedOutputStream(of);
        ) {
            // 创建临时存储空间，存储读取出的字节
            byte[] byteData = new byte[1024];
            // 记录当前批次存储了多少字节
            int len;
            // 循环与硬盘交互
            while ((len = bis.read(byteData)) != -1) {
                // 读取的内容是根据data读取多少字节，就输出到多少字节。
                // 将当批次获得的字节数据，通过字节缓冲输出流，写入到另一个File文件
                bos.write(byteData, 0, len);
            }
        } catch (IOException e) {
            System.out.println("文件复制失败：" + e.getMessage());
        }

    }


}

import java.io.IOException;  // IO异常处理类
import java.io.File;         // File文件对象
import java.io.FileReader;   // 文本字符输入流
import java.io.FileWriter;   // 文本字符输出流
import java.io.BufferedReader;   // 文本字符缓冲输入流
import java.io.BufferedWriter;   // 文本字符缓冲输出流


public class Main {
    public static void main(String[] ages) {
        // 实例化File对象，添加需要复制的源文件
        File file = new File("/home/file.text");
        // 实例化File对象，添加需要复制的新文件
        File fileCopy = new File("/home/fileCopy.text");

        try (
                // 实例化字符输入流，添加要读取的File对象
                FileReader fr = new FileReader(file);
                // 实例化字符缓冲输入流，包装原始字符输入流，即添加缓冲区
                BufferedReader br = new BufferedReader(fr);

                // 实例化字符输出流，添加要写入的File对象
                FileWriter fw = new FileWriter(fileCopy);
                // 实例化字符缓冲输出流，包装原始字符输出流，即添加缓冲区
                BufferedWriter bw = new BufferedWriter(fw);
        ) {
            // 创建临时存储空间，存储读取出的字符
            char[] charArray = new char[1024];
            // 记录当前批次存储了多少字符
            int len;
            // 循环与硬盘交互
            while ((len = br.read(charArray)) != -1) {
                // 将当批次获得的字符数据，通过字节缓冲输出流，写入到另一个File文件
                bw.write(charArray, 0, len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }


}

import java.io.*;

public class Main {
    public static void main(String[] ages) {

        // 实例化File对象
        File file = new File("/home/file.text");

        try (
                // 实例化文件字节输出流，添加需要写入数据的File对象
                FileOutputStream fos = new FileOutputStream(file);
                // 实例化对象字节输出流，添加文件字节输出流
                ObjectOutputStream oos = new ObjectOutputStream(fos);
        ) {
            // 创建对象，该对象的类必须继承`Serializable`接口
            User user = User("姓名", 18);
            // 通过对象通过对象字节输出流，将对象写入文件
            oos.writeObject(user);

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }


}

import java.io.*;

public class Main {
    public static void main(String[] ages) {

        // 实例化File对象
        File file = new File("/home/file.text");

        try (
                // 实例化文件字节输入流，添加需要读取数据的File对象
                FileInputStream fos = new FileInputStream(file);
                // 实例化对象字节输入流，添加文件字节输入流
                ObjectIntputStream oos = new ObjectIntputStream(fos);
        ) {
            // 通过对象通过对象字节输出流，将对象读取出来
            // (重点)获得将对象文件后，需要手动强转成User对象数据类型
            User user = (User)oos.writeObject(user);

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }


}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


public class Main {
    public static void main(String[] ages) {
        // 实例化File对象，添加要读取的文件
        File file = new File("/home/file.text");
        // 实例化File对象，添加要复制写入的文件
        File fileCopy = new File("/home/fileCopy.text");

        // 实例化字节输入流对象
        InputStream inputFile = null;
        // 实例化字节输出流对象
        OutputStream outputFile = null;

        try {
            // 传入需要读取的File文件对象
            inputFile = new FileInputStream(file);
            // 传入需要写入的File文件对象
            outputFile = new FileOutputStream(fileCopy);

            // 类似缓存区，一批次能读取多少字节
            byte[] byteData = new byte[3];
            // 记录当前批次读取了多少字节
            int len;
            while ((len = inputFile.read(byteData)) != -1) {
                // 读取的内容是根据data读取多少字节，就输出到多少字节。
                // 将读取到的字节数据，通过字节输出流对象，写入到文件
                outputFile.write(byteData, 0, len);
            }

        } catch (IOException e) {
            System.out.println("文件复制失败：" + e.getMessage());

        } finally {
            // 释放输出流对象资源
            try {
                // 判断输出流对象是否已经关闭
                if (outputFile != null) {
                    // 释放输出流对象
                    outputFile.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 释放输入流对象资源
            try {
                // 判断输入流对象是否已经关闭
                if (inputFile != null) {
                    // 释放输出流对象
                    inputFile.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }


}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


public class Main {
    public static void main(String[] ages) {
        // 实例化File对象，添加要读取的文件
        File file = new File("/home/file.text");
        // 实例化File对象，添加要复制写入的文件
        File fileCopy = new File("/home/fileCopy.text");

        try (
                // 实例化字节输入流对象，传入需要读取的File文件对象
                InputStream inputFile = new FileInputStream(file);
                // 实例化字节输出流对象，传入需要写入的File文件对象
                OutputStream outputFile = new FileOutputStream(fileCopy);
        ) {
            
            // 类似缓存区，一批次能读取多少字节
            byte[] byteData = new byte[3];
            // 记录当前批次读取了多少字节
            int len;
            while ((len = inputFile.read(byteData)) != -1) {
                // 读取的内容是根据data读取多少字节，就输出到多少字节。
                // 将读取到的字节数据，通过字节输出流对象，写入到文件
                outputFile.write(byteData, 0, len);
            }

        } catch (IOException e) {
            System.out.println("文件复制失败：" + e.getMessage());
        }

    }


}