Java中文件的操作与输入输出流举例详解

public class Demo01_File {
    public static void main(String[] args) {
        //通过指定文件路径来创建一个File对象
        File file = new File("D:\\test\\hello.txt");
        System.out.println(file);
        File file1 = new File("D:/test/hello.txt");
        System.out.println(file1);
        //这只是java层面的一个对象，并不一定必须在系统中真实存在
        File file2 = new File("D:/test/test.txt");
        System.out.println(file2);
    }
}

public class Demo02_FileUsae {
    public static void main(String[] args) throws IOException {
        //指定绝对路径来创建一个File对象
        File file = new File("D:/test/test.txt");
        // 获取父目录
        System.out.println(file.getParent());
        // 获取文件名
        System.out.println(file.getName());
        // 获取路径
        System.out.println(file.getPath());
        // 获取绝对路径
        System.out.println(file.getAbsolutePath());
        // 获取一个标准路径
        System.out.println(file.getCanonicalPath());
        // 是否存在
        System.out.println(file.exists());
        // 是不是一个目录
        System.out.println(file.isDirectory());
        // 是不是一个文件
        System.out.println(file.isFile());
//
//        // 创建文件
//        boolean result1 = file.createNewFile();
//        if (result1) {
//            System.out.println("创建成功");
//        } else {
//            System.out.println("创建失败");
//        }
//
//        // 删除
//        boolean result2 = file.delete();
//        if (result2) {
//            System.out.println("删除成功");
//        } else {
//            System.out.println("删除失败");
//        }

//        // 指定一个目录的路径
//        File file = new File("d:/test");
//        // 获取目录下的文件和子目录
//        String[] list = file.list();
//        System.out.println(Arrays.toString(list));
//
//        // 获取目录下的文件对象数组
//        File[] files = file.listFiles();
//        System.out.println(Arrays.toString(files));

//        // 指定要创建的目录
//        File file = new File("D:/test/java");
//        // 创建单个目录
//        boolean result = file.mkdir();
//        if (result) {
//            System.out.println("创建成功");
//        } else {
//            System.out.println("创建失败");
//        }
//        // 指定要创建的目录
//        File file = new File("D:/test/java/a/b/c");
//        // 创建单个目录
//        boolean result = file.mkdirs();
//        if (result) {
//            System.out.println("创建成功");
//        } else {
//            System.out.println("创建失败");
//        }
//        // 定义源文件
//        File sourceFile = new File("D:/test/hello.txt");
//        // 定义目标文件
//        File destFile = new File("D:/test/haha.txt");
//        // 重命名
//        boolean result = sourceFile.renameTo(destFile);
//        if (result) {
//            System.out.println("修改成功");
//        } else {
//            System.out.println("修改失败");
//        }
//
//        File file = new File("D:/test/haha.txt");
//        // 是否可写
//        System.out.println(file.canWrite());
//        // 是否可读
//        System.out.println(file.canRead());



//        //指定相对路径来创建一个File对象
//        File file = new File("./test.txt");
//        // 获取父目录
//        System.out.println(file.getParent());
//        // 获取文件名
//        System.out.println(file.getName());
//        // 获取路径
//        System.out.println(file.getPath());
//        // 获取绝对路径
//        System.out.println(file.getAbsolutePath());
//        // 获取一个标准路径
//        System.out.println(file.getCanonicalPath());
//        // 是否存在
//        System.out.println(file.exists());
//        // 是不是一个目录
//        System.out.println(file.isDirectory());
//        // 是不是一个文件
//        System.out.println(file.isFile());
    }
}

public class Demo03_InputStream_Read01 {
    public static void main(String[] args) throws IOException {
        // 创建一个文件对象
        File file = new File("d:/test/haha.txt");
        // 创建一个输入流
        InputStream inputStream = new FileInputStream(file);
        // 读取文件内容
        while (true) {
            int read = inputStream.read();
            // 是否读完
            if (read == -1) {
                break;
            }
            System.out.println(read);
        }
        // 关闭
        inputStream.close();
    }
}

public class Demo04_InputStream_Read02 {
    public static void main(String[] args) throws IOException {
        // 创建一个文件对象
        File file = new File("d:/test/haha.txt");
        // 创建一个输入流
        InputStream inputStream = new FileInputStream(file);
        // 定义一个数组用来保存读取到的数据
        byte[] bytes = new byte[1024];
        // 读取文件内容
        while (true) {
            // 读到的数据会被填充到bytes数据中，返回读取数据的长度
            int len = inputStream.read(bytes);
            // 判断是否读完
            if (len == -1) {
                break;
            }
            // 打印读到的内容
            for (int i = 0; i < len; i++) {
                System.out.println(bytes[i]);
            }
        }
        // 关闭
        inputStream.close();
    }
}

public class Demo05_OutputStream {
    public static void main(String[] args) throws IOException {
        // 先创建一个File对象
        File file = new File("d:/test/haha.txt");
        // 根据File对象创建一个输出流
        FileOutputStream outputStream = new FileOutputStream(file);
        // 向文件中写入内容
        outputStream.write(100);
        outputStream.write(101);
        outputStream.write(102);
        // 刷新缓冲区
        outputStream.flush();
        // 关闭流
        outputStream.close();
    }
}

public class Demo06_FileReader {
    public static void main(String[] args) throws IOException {
        // 创建一个File对象
        File file = new File("d:/test/haha.txt");
        // 根据File对象创建一个Reader(面向字符的输入流)
        FileReader reader = new FileReader(file);
        // 循环读取
        while (true) {
            // 一次读一个字符
            int read = reader.read();
            if (read == -1) {
                break;
            }
            // 打印
            System.out.println((char) read);
        }
        // 关闭流
        reader.close();
    }
}

public class Demo07_FileWriter {
    public static void main(String[] args) throws IOException {
        // 创建一个File对象
        File file = new File("d:/test/haha.txt");
        // 根据文件对象创建一个字符输出流
        FileWriter writer = new FileWriter(file);
        // 写入内容
        writer.write("你好世界\n");
        writer.write("hello world");
        // 强制刷新缓冲区
        writer.flush();
        // 关闭流
        writer.close();

    }
}

public class Demo08_Scanner {
    public static void main(String[] args) throws IOException {
        // 创建一个输入流
        FileInputStream inputStream = new FileInputStream("d:/test/hello.txt");
        // 根据创建输入流创建Scanner对象
        Scanner scanner = new Scanner(inputStream, "UTF-8");
        // 循环读取内容
        while (scanner.hasNextLine()) {
            String next = scanner.nextLine();
            System.out.println(next);
        }
        scanner.close();
        inputStream.close();
    }
}

public class Demo09_PrintWiter {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建一个输出流
        FileOutputStream outputStream = new FileOutputStream("d:/test/hello.txt");
        // 根据输出流，创建一个PrintWriter
        PrintWriter printWriter = new PrintWriter(outputStream);
        // 写入文件
        printWriter.println("你好世界！！！");
        printWriter.println("hello world.");
        printWriter.println("我是用PrintWriter写入的内容");
        // 强制刷新缓冲区
        printWriter.flush();
        // 关闭流
        printWriter.close();
    }
}

public class Ex01 {
    public static void main(String[] args) throws IOException {
        // 1. 接收用户输入的扫描路径
        System.out.println("请输入要扫描的路径(绝对路径):");
        Scanner scanner = new Scanner(System.in);
        String rootPath = scanner.next();
        // 2. 判断路径是否有效
        File root = new File(rootPath);
        // 2.1 路径是否存在
        if (!root.exists()) {
            System.out.println("路径不存在");
            return;
        }
        // 2.2 判断File是不是一个目录
        if (!root.isDirectory()) {
            System.out.println("指定的路径不是一个有效目录");
            return;
        }
        // 3. 接收关键字
        System.out.println("请输入关键字");
        String key = scanner.next();
        if (key == null || "".equals(key)) {
            System.out.println("关键字不能为为");
            return;
        }
        // 4. 扫描目录下的所有文件
        scan(root, key);
    }

    private static void scan(File root, String key) throws IOException {
        // 1. 先获取root下的所有文件，包括目录
        File[] files = root.listFiles();
        // 递归的终止条件
        if (files == null || files.length == 0) {
            return;
        }
        // 遍历数组中的每个文件
        for (int i = 0; i < files.length; i++) {
            // 取出每一个文件
            File tempFile = files[i];
            // 判断是文件还是目录
            if (tempFile.isFile()) {
                // 如果是文件，判断文件名中是否包含关键字
                String fileName = tempFile.getName();
                // 如果在文件名中找到关键字
                if (fileName.contains(key)) {
                    System.out.println("找到文件：" + tempFile.getCanonicalPath() + ", 是否删除(Y/N)");
                    // 接收用户的输入，根据输入判断是否删除
                    Scanner scanner = new Scanner(System.in);
                    String order = scanner.next();
                    // 删除操作
                    if (order.equalsIgnoreCase("y")) {
                        tempFile.delete();
                        System.out.println(tempFile.getCanonicalPath() + " 删除成功.");
                    }
                }
            } else {
                // 如果是目录则递归
                scan(tempFile, key);
            }
        }
    }
}

public class Ex02 {
    public static void main(String[] args) {
        // 1 . 接收用户输入的源文件路径
        System.out.println("请输入源文件路径(绝对路径)：");
        Scanner scanner = new Scanner(System.in);
        String sourcePath = scanner.next();
        // 2. 判断源文件路径是否有效
        File sourceFile = new File(sourcePath);
        // 2.1 文件是否存在
        if (!sourceFile.exists()) {
            System.out.println("源文件不存在");
            return;
        }
        // 2.2 判断是不是一个文件
        if (!sourceFile.isFile()) {
            System.out.println("源文件不是一个有效的文件");
            return;
        }
        // 3. 接收用户输入的目标文件路径
        System.out.println("请输入目标文件路径(绝对路径)");
        String destPath = scanner.next();
        File destFile = new File(destPath);
        // 3.1 判断目标文件是否存在
        if (destFile.exists()) {
            System.out.println("目标文件已存在");
            return;
        }
        // 3.2 判断目标文件的父目录是否存在
        if (!destFile.getParentFile().exists()) {
            System.out.println("目标文件的父目录不存在");
            return;
        }
        // 循环读取源文件的内容并写到目标文件中
        try (FileInputStream inputStream = new FileInputStream(sourceFile);
             FileOutputStream outputStream = new FileOutputStream(destFile)) {
            // 定义一个byte数组用来做为输出型参数，保存每次读到的文件内容
            byte [] bytes = new byte[1024];
            // 循环读取内容
            while (true) {
                int len = inputStream.read(bytes);
                if (len == -1) {
                    break;
                }
                // 写义目标文件
                outputStream.write(bytes);
                // 强制刷新缓冲区
                outputStream.flush();
            }
            System.out.println("复制成功");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}