// 文件创建 - 案例
public class File01 {
    public static void main(String[] args) {

    }

    @Test
    public void createFile01() throws IOException {
        // 获取 当前文件路径
        String filePath = getClass().getResource("").getPath();
        System.out.println(filePath);

        File file1 = new File(filePath + "test1.txt");
        file1.createNewFile();
    }

    @Test
    public void createFile02() throws IOException {
        // 获取 当前文件路径
        String filePath = getClass().getResource("").getPath();
        System.out.println(filePath);

        String fileName = "test2.txt";
        File file1 = new File(filePath,fileName);
        file1.createNewFile();
    }

    @Test
    public void createFile03() throws IOException {
        // 获取 当前文件路径
        String filePath = getClass().getResource("").getPath();
        System.out.println(filePath);

        String fileName = "test2.txt";
        File file1 = new File(filePath,fileName);
        file1.createNewFile();
    }
}

// 目录创建及删除 - 案例
public class Dir01 {
    public static void main(String[] args) {

    }

    @Test
    public void m1() throws IOException {
        String filePath = getClass().getResource("").getFile();
        File file = new File(filePath + "test2.txt");
        // 创建文件
        file.createNewFile();
        System.out.println("创建文件成功");

        // 删除文件
        if (file.exists()){
            file.delete();
            System.out.println("删除成功");
        }
    }

    @Test
    public void m2() throws IOException {
        String filePath = getClass().getResource("").getFile();
        File file = new File(filePath + "test2");

        // 判断目录是否存在,存在就删除,不存在就创建
        if (!(file.exists())){
            file.mkdir();
            System.out.println("创建目录");
        }else {
            file.delete();
            System.out.println("删除目录");
        }
    }

    @Test
    public void m3() throws IOException {
        String filePath = getClass().getResource("").getFile();
        System.out.println(filePath);
        File file = new File(filePath + "test1\\test2\\test3");

        // 判断目录是否存在,存在就删除,不存在就创建
        if (!(file.exists())){
            file.mkdirs();
            System.out.println("创建目录");
        }else {
            file.delete();
            System.out.println("删除目录");
        }
    }
}

// 字节流 输入（读取文件）
public class InputStream01 {
    public static void main(String[] args) {

    }

    /**
     * 1. 单个字节读取
     * 2. 使用字节流读取文件中的中文内容,会造成乱码
     */
    @Test
    public void fileInputStream1() throws IOException {
        String filePath = Objects.requireNonNull(getClass().getResource("")).getPath();
        System.out.println(filePath);

        FileInputStream fileInputStream = new FileInputStream(filePath + "hello.txt");

        int data = 0;
        // 返回 -1,表示读取完毕
        while ((data = fileInputStream.read()) != -1){
            System.out.println((char) data);
        }
        // 读取完成后需要关闭文件流, 释放资源
        fileInputStream.close();
    }

    /**
     * 根据字符数组读取
     */
    @Test
    public void fileInputStream2() throws IOException {
        String filePath = Objects.requireNonNull(getClass().getResource("")).getPath();
        System.out.println(filePath);

        FileInputStream fileInputStream = new FileInputStream(filePath + "hello.txt");

        int readLen;
        // 一次读取 8 个字节
        byte[] buf = new byte[8];
        // 返回 -1,表示读取完毕
        while ((readLen = fileInputStream.read(buf)) != -1){
            String s = new String(buf, 0, readLen);
            System.out.println(s);
        }
        // 读取完成后需要关闭文件流, 释放资源
        fileInputStream.close();
    }
}

// 字节流 输出（写入文件）
public class OutputStream01 {
    public static void main(String[] args) {

    }

    /**
     * 写入文件
     */
    @Test
    public void fileOutput() throws IOException {
        // 获取文件路径
        String filePath = Objects.requireNonNull(getClass().getResource("")).getPath();
        String fileName = "test1.txt";
        File file = new File(filePath + fileName);

        // 判断文件是否存在
        if (!(file.exists())){
            if(file.createNewFile()) {
                System.out.println("创建文件成功");
            }else {
                System.out.println("创建失败");
            }
        }

        OutputStream outputStream = new FileOutputStream(filePath + fileName);
        String s = "hello, Jack chen";

        // 单个字节写入文件
        char[] n = s.toCharArray();
        for (char c : n) {
            outputStream.write(c);
        }

        // 字节数组写入, str.getBytes 字符串 转 字节数组
        outputStream.write(s.getBytes());

        // 字节数组部分写入, 从 off 开始, 向右偏移 len 个字符
        outputStream.write(s.getBytes(), 4, s.length()-5);

        // 退出文件,释放资源
        outputStream.close();
    }
}

// 文件 拷贝 - 案例
public class FileCopy1 {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 获取当前项目路径
        File af = new File("").getAbsoluteFile();
        // 拼接文件 和 文件夹 路径
        String folderPath = af + "/src/com/file_/demo";
        String filePath1 = af + "/src/com/file_/1.jpg";
        String filePath2 = af + "/src/com/file_/demo/demo.jpg";

        // 创建文件 和 文件夹对象
        File folder = new File(folderPath);
        File file = new File(filePath2);

        // 创建文件夹
        if (folder.exists()){
            System.out.println("文件夹已存在"+ folder);
        }else {
            if (folder.mkdir()){
                System.out.println("创建文件夹成功");
            }
        }

        // 新建图片文件
        file.createNewFile();

        byte[] b = new byte[1024];
        int data;
        // 创建输入流 和 输出流
        FileInputStream fileInputStream = new FileInputStream(filePath1);
        FileOutputStream fileOutputStream = new FileOutputStream(file, true);
        while ((data = fileInputStream.read(b)) != -1){
            fileOutputStream.write(b, 0, data);
        }

        // 关闭输入流和输出流
        fileInputStream.close();
        fileOutputStream.close();
    }
}

// 字符流 输入（读取文件）
public class FileReader1 {
    public static void main(String[] args) {

    }

    public void read1() throws IOException {
        // 获取文件路径
        String absolutePath = new File("").getAbsolutePath();
        System.out.println(absolutePath);

        // 创建文件对象
        FileReader fileReader = new FileReader(absolutePath + "/src/com/io_/hello.txt");
        int data;

        // 读取文件
        while ((data = fileReader.read()) != -1) {
            System.out.print((char) data);
        }

        // 关闭文件
        fileReader.close();
    }

    @Test
    public void read2() throws IOException {
        // 获取文件路径
        String absolutePath = new File("").getAbsolutePath();
        System.out.println(absolutePath);

        // 创建文件对象
        FileReader fileReader = new FileReader(absolutePath + "/src/com/io_/hello.txt");
        int data = 0;
        char[] c = new char[1024];

        // 读取文件
        while ((data = fileReader.read(c)) != -1) {
            System.out.print(new String(c, 0, data));
        }

        // 关闭文件
        fileReader.close();
    }
}

public class FileWriter1 {
    public static void main(String[] args) {

    }

    /**
     * 从一个文件中读取,写入另一个文件
     */
    @Test
    public void writer1() throws IOException {
        // 获取文件路径
        String absolutePath = new File("").getAbsolutePath();
        System.out.println(absolutePath);

        // 创建文件对象
        File demo1 = new File(absolutePath + "/src/com/io_/demo1.txt");
        if (!(demo1.exists())){
            if (demo1.createNewFile()){
                System.out.println("文件创建成功");
            }
        }

        FileReader fileReader = new FileReader(absolutePath + "/src/com/io_/hello.txt");
        FileWriter w1 = new FileWriter(absolutePath + "/src/com/io_/demo1.txt", true);
        int data = 0;
        char[] c = new char[1024];

        // 读取文件
        while ((data = fileReader.read(c)) != -1) {
            w1.write(new String(c, 0, data));
        }

        // 关闭文件
        fileReader.close();
        w1.close();
    }
}

public class Reader1 {
    public static void main(String[] args) {

    }
    @Test
    public void read1() throws IOException {
        // 获取文件路径
        String absolutePath = new File("").getAbsolutePath();
        System.out.println(absolutePath);

        // 创建文件对象
        FileReader fileReader = new FileReader(absolutePath + "/src/com/io_/hello.txt");
        BufferedReader br = new BufferedReader(fileReader);
        String data;

        // 读取文件   br.readLine() 按行读取
        while ((data = br.readLine()) != null) {
            System.out.println(data);
        }

        // 关闭文件, 只需关闭处理流即可
        br.close();
    }
}

public class Writer1 {
    public static void main(String[] args) {

    }

    /**
     * 从一个文件中读取,写入另一个文件
     */
    @Test
    public void writer1() throws IOException {
        // 获取文件路径
        String absolutePath = new File("").getAbsolutePath();
        System.out.println(absolutePath);

        // 创建文件对象
        File demo1 = new File(absolutePath + "/src/com/io_/demo1.txt");
        if (!(demo1.exists())){
            if (demo1.createNewFile()){
                System.out.println("文件创建成功");
            }
        }

        FileReader fileReader = new FileReader(absolutePath + "/src/com/io_/hello.txt");
        FileWriter w1 = new FileWriter(absolutePath + "/src/com/io_/demo1.txt", true);
        BufferedReader r = new BufferedReader(fileReader);
        BufferedWriter w = new BufferedWriter(w1);
        String data;

        // 读取文件
        while ((data = r.readLine()) != null) {
            w.write(data);
            // 换行
            w.newLine();
        }

        // 关闭文件
        r.close();
        w.close();
    }
}

public class BufferedReaderWriter1 {
    public static void main(String[] args) {

    }

    @Test
    public void writer1() throws IOException {
        // 获取文件路径
        String absolutePath = new File("").getAbsolutePath();
        System.out.println(absolutePath);

        // 创建文件对象
        File demo1 = new File(absolutePath + "/src/com/io_/demo.mp4");
        if (!(demo1.exists())){
            if (demo1.createNewFile()){
                System.out.println("文件创建成功");
            }
        }

        FileInputStream fileInput = new FileInputStream(absolutePath + "/src/com/io_/iShot_2022-06-06_15.39.50.mp4");
        FileOutputStream fileOutput = new FileOutputStream(absolutePath + "/src/com/io_/demo.mp4", true);
        BufferedInputStream i = new BufferedInputStream(fileInput);
        BufferedOutputStream o = new BufferedOutputStream(fileOutput);

        byte[] b = new byte[1024];
        int data = 0;

        // 读取文件
        while ((data = i.read(b)) != -1) {
            o.write(b, 0, data);
        }

        // 关闭文件
        o.close();
        i.close();
    }
}

public class ObjectInput1 {
    public static void main(String[] args) {

    }

    // 序列化
    @Test
    public void objectOutputStream1() throws IOException {
        // 获取文件路径
        String filePath = new File("").getAbsolutePath() + "/src/com/io_/demo1.json";
        new File(filePath).createNewFile();     // 创建文件

        // 创建对象序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        // 基本数据类型的包装类 实现了 Serializable
        oos.writeInt(100);
        oos.writeBoolean(true);
        oos.writeChar('a');
        oos.writeUTF("李焕英");    // 字符串

        Dog dog = new Dog("旺财", 10);
        oos.writeObject(dog);

        oos.close();
    }

    // 反序列化
    @Test
    public void objectInputStream1() throws IOException, ClassNotFoundException {
        // 获取文件路径
        String filePath = new File("").getAbsolutePath() + "/src/com/io_/demo1.json";

        // 创建对象序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        // 反序列化
        // 读取的顺序 必须 和 序列化的顺序一致
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readUTF());
        System.out.println(ois.readObject());

        ois.close();
    }
}


class Dog implements Serializable{
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class InputStreamReader1 {

    @Test
    public void transition1() throws IOException {
        String filePath = new File("").getAbsolutePath() + "/src/com/io_/hello.txt";
        FileInputStream fis = new FileInputStream(filePath);

        // 将字节流 转为 字符流,编码为 utf-8
        InputStreamReader isr = new InputStreamReader(fis, "UTF-8");

        // 将字符流 转为 BufferedReader
        BufferedReader br = new BufferedReader(isr);
        String s;
        while ((s = br.readLine()) != null){
            System.out.println(s);
        }

        br.close();
    }
}

public class OutputStreamWriter1 {

    @Test
    public void transition1() throws IOException {
        String filePath = new File("").getAbsolutePath() + "/src/com/io_/hello.txt";

        FileOutputStream fos = new FileOutputStream(filePath);

        // 将字符流 转为 字节流,编码为 utf-8
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos, StandardCharsets.UTF_8));

        bw.write("你好,李焕英");

        // 将字符流 转为 BufferedReader
        bw.close();
    }
}

public class PrintStream1 {
    public static void main(String[] args) {
    }

    @Test
    public void print1() throws IOException {

        PrintStream out = System.out;
        out.print("你好,你不好");

        // 因为 print 底层使用的是 write,所以可以直接调用 write 进行打印/输出
        out.write("天王盖地虎".getBytes(StandardCharsets.UTF_8));

        // 创建文件
        String filePath = new File("").getAbsolutePath()+"/src/com/io_/demo2.txt";
        new File(filePath).createNewFile();

        // 修改打印 设备, 到文件 demo2.txt
        System.setOut(new PrintStream(filePath));
        // 不会打印到控制台, 会保存到文件
        System.out.println("宝塔管水貂");

        out.close();
    }
}

public class PrintWriter1 {
    public static void main(String[] args) {
    }

    @Test
    public void print1() throws IOException {

        // PrintWriter writer = new PrintWriter(System.out);
        // writer.print("你好,你不好");

        // 创建文件
        String filePath = new File("").getAbsolutePath()+"/src/com/io_/demo3.txt";
        File file = new File(filePath);
        if (!(file.exists())) {
            if (new File(filePath).createNewFile()){
                System.out.println("文件创建成功");
            }
        }else{
            System.out.println("文件已存在");
        }
        // 修改打印 设备, 到文件 demo3.txt
        PrintWriter printWriter = new PrintWriter(filePath);

        // 不会打印到控制台, 会保存到文件
        printWriter.print("宝塔管水貂");

        printWriter.close();
    }
}

public class Properties1 {
    public static void main(String[] args) {

    }
    @Test
    public void proper () throws IOException {
        // 获取文件路径
        String filePath = new File("").getAbsolutePath()+"/src/com/properties_/mysql.properties";
        File file = new File(filePath);

        // 判断文件是否存在,如果不存在就创建文件
        if (!(file.exists())){
            if(file.createNewFile()){
                System.out.println("文件创建成功" + filePath);
            }
        }else {
            System.out.println("文件已存在" + filePath);
        }

        // 创建 Properties 对象
        Properties properties = new Properties();

        // 加载指定配置文件
        properties.load(new FileReader(file));

        // 以 k-v 的形式显示所有的内容
        properties.list(System.out);

        // 根据 k 获取值
        String user = properties.getProperty("user");
        System.out.println(user);

        // 修改 文件
        properties.setProperty("user", "Pupper");
        properties.list(System.out);

        // 添加 内容
        properties.setProperty("server", "测试服务器");
        properties.list(System.out);

        // 删除内容
        properties.remove("ip");
        properties.list(System.out);

        // 保存 配置 文件
        properties.store(new FileOutputStream(
                new File("").getAbsolutePath()+"/src/com/properties_/demo1.properties"),
                "这里是一个注释,可以为 null");
    }
}