文件系统操作

常见API

在Java中，File类是用于文件和目录路径名的抽象表示。以下是一些常见的方法：

1. 构造方法：

   • File(String pathname)：根据给定的路径创建一个File对象。
   • File(String parent, String child)：根据父路径和子路径创建一个File对象。
   • File(File parent, String child)：根据父File对象和子路径创建一个File对象。

2. 文件或目录的基本信息：

   • boolean exists()：判断文件或目录是否存在。
   • boolean isFile()：判断是否为一个普通文件。
   • boolean isDirectory()：判断是否为一个目录。
   • String getName()：获取文件或目录的名称。
   • String getPath()：获取路径名称。
   • long length()：获取文件的字节长度。

3. 文件操作：

   • boolean createNewFile()：创建一个新文件，如果文件已存在则返回false。
   • boolean delete()：删除文件或目录。
   • boolean mkdir()：创建一个新目录。
   • boolean mkdirs()：创建多级目录。
   • boolean renameTo(File dest)：重命名文件或目录。

4. 文件的读写：

   • File[] listFiles()：列出目录中的所有文件和子目录。
   • String[] list()：列出目录中的所有文件和子目录的名称。

5. 路径操作：

   • String getAbsolutePath()：获取文件的绝对路径。
   • String getParent()：获取文件父目录的路径。

6. 权限和属性：

   • boolean canRead()：判断文件是否可读。
   • boolean canWrite()：判断文件是否可写。
   • boolean canExecute()：判断文件是否可执行。

这些方法为文件和目录的创建、删除、重命名及信息获取提供了方便的API。可以根据需要使用这些方法进行文件管理操作。

经典面试题

扫描指定文件目录，找到文件名包含指定字符的所有普通文件，让用户判断是否删除该文件

import java.io.File;  // 导入File类，用于处理文件和目录
import java.util.Scanner;  // 导入Scanner类，用于接收用户输入

public class Example {
    public static void main(String[] args) {
        // 创建Scanner对象以接收用户输入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要查找的路径名：");
        String path = scanner.next();  // 读取用户输入的路径名
        File rootPath = new File(path);  // 创建File对象

        // 检查输入的路径是否是一个目录
        if (!rootPath.isDirectory()) {
            System.out.println("你输入的不是一个合法的路径！！！");
            return;  // 如果不是合法路径，结束程序
        }

        System.out.println("请输入要删除文件的关键词：");
        String word = scanner.next();  // 读取用户输入的关键词

        scanDir(rootPath, word);  // 调用scanDir方法进行目录扫描
    }

    // 递归扫描目录，查找含有特定关键词的文件
    private static void scanDir(File path, String word) {
        File[] files = path.listFiles();  // 列出当前目录下的所有文件和子目录
        if (files == null) {
            return;  // 如果没有文件，返回
        }

        // 遍历文件数组
        for (File file : files) {
            // 如果当前项是文件，则检查是否需要删除
            if (file.isFile()) {
                checkDelete(file, word);  // 调用checkDelete方法检查文件
            } else {
                // 如果当前项是目录，递归调用scanDir方法
                scanDir(file, word);  
            }
        }
    }

    // 检查文件名是否包含关键词，并处理删除操作
    private static void checkDelete(File file, String word) {
        // 检查文件名是否包含指定的关键词
        if (file.getName().contains(word)) {
            System.out.println(file.getName());  // 打印匹配的文件名
            System.out.println("是否删除该文件？");  // 提问用户是否删除
            Scanner scanner = new Scanner(System.in);
            String check = scanner.next();  // 读取用户输入的确认信息

            // 如果用户输入"shi"，表示确认删除
            if (check.equals("shi")) {
                boolean delete = file.delete();  // 尝试删除文件
                if (delete) {
                    System.out.println("删除成功！");  // 删除成功提示
                } else {
                    System.out.println("删除失败！");  // 删除失败提示
                }
            } else {
                return;  // 如果用户不想删除，返回
            }
        } else {
            return;  // 如果文件名不包含关键词，返回
        }
    }
}

运行效果如下：

文件内容操作 

Read 类常见API

在Java中，Reader类是一个抽象类，主要用于读取字符流。常用的Reader子类包括FileReader、BufferedReader、InputStreamReader等。以下是一些常见的Reader类的方法：

1. 构造方法：

   • Reader()：创建一个新的Reader对象（需要子类实现具体功能）。

2. 读取字符：

   • int read()：读取单个字符并返回，返回-1表示流的末尾。
   • int read(char[] cbuf)：将字符读入数组中，返回实际读取的字符数量，返回-1表示流的末尾。
   • int read(char[] cbuf, int off, int len)：从字符输入流中读取字符并将其存储到字符数组的一个部分中，返回实际读取的字符数量。

3. 跳过字符：

   • long skip(long n)：跳过字符流中的n个字符并返回实际跳过的字符数量。

4. 查找方法：

   • boolean ready()：判断是否可以读取更多字符，如果可以，返回true。

5. 关闭流：

   • void close()：关闭流并释放相关资源。

6. 获取字符流信息：

   • String toString()：返回此Reader的字符串表示（由具体实现决定）。

7. 读取文本行（通常用于BufferedReader）：

   • String readLine()：读取一行字符，返回字符串，返回null表示流的末尾。

这些方法提供了字符流的读取功能，适用于处理文本数据。如果需要处理特定类型的输入或文件，通常会选择相应的子类，例如使用FileReader读取文件，使用BufferedReader提高读取效率等。

Writer 类常见API

在Java中，Writer类是一个抽象类，用于写入字符流。常用的Writer子类包括FileWriter、BufferedWriter、PrintWriter等。以下是一些常见的Writer类的方法：

1. 构造方法：

   • Writer()：创建一个新的Writer对象（需要子类实现具体功能）。

2. 写入字符：

   • void write(int c)：写入单个字符。
   • void write(char[] cbuf)：将字符数组的内容写入流中。
   • void write(String str)：将字符串的内容写入流中。
   • void write(String str, int off, int len)：写入字符串的一部分，从指定的偏移量开始，最多写入指定的字符数。

3. 缓冲：

   • void flush()：刷新该流，确保所有缓存的字符都被写入目标流中。

4. 关闭流：

   • void close()：关闭流并释放与之关联的所有资源。

5. 写入字符数组：

   • void write(char[] cbuf, int off, int len)：将数组中指定范围内的字符写入流中。

6. 换行方法（通常用于BufferedWriter）：

   • void newLine()：写入一个行分隔符，通常用于文本文件的换行。

7. 格式化输出（通常用于PrintWriter）：

   • void printf(String format, Object... args)：按照给定的格式输出。
   • void println()：写入一个行分隔符（换行）。

这些方法提供了字符流的写入功能，非常适合处理文本文件和输出。不同的Writer实现提供了不同的功能，例如BufferedWriter提供缓存功能以提高效率，而PrintWriter则提供方便的格式化输出功能。根据具体需求，可以选择适当的Writer实现。

经典面试题

将一个文件中的内容完整复制到另一个文件中

题目描述： 请编写一个Java程序，使用Reader和Writer类，将一个文本文件中的内容复制到另一个文本文件中。请考虑使用合适的子类以提高程序的效率，并确保在读取和写入时处理异常。程序需具备以下功能：

1. 从源文件中读取内容。
2. 将读取的内容写入目标文件。
3. 需要在控制台提示用户输入源文件路径和目标文件路径。
4. 在文件操作完成后，提示用户操作结果（如复制成功、失败等）。

示例代码：

下面是一个简单的实现示例：

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        // 使用Scanner获取用户输入的文件路径
        try (Scanner scanner = new Scanner(System.in)) {
            System.out.println("请输入源文件路径：");
            String sourcePath = scanner.nextLine(); // 读取源文件路径
            System.out.println("请输入目标文件路径：");
            String destPath = scanner.nextLine(); // 读取目标文件路径

            // 创建文件Reader和Writer对象
            try (Reader reader = new FileReader(sourcePath);
                 Writer writer = new FileWriter(destPath)) {

                char[] buffer = new char[1024]; // 创建缓冲区
                int length;
                // 循环读取源文件内容，并写入目标文件
                while ((length = reader.read(buffer)) != -1) {
                    writer.write(buffer, 0, length); // 写入缓冲区中的内容
                }

                System.out.println("文件复制成功！"); // 提示成功消息
            } catch (IOException e) {
                System.out.println("文件操作失败：" + e.getMessage()); // 提示错误消息
            }
        }
    }
}

注意事项

1. 确保输入的文件路径是有效的，并且有权限读取源文件和写入目标文件。
2. 处理可能出现的异常，如文件未找到或无法读取/写入的情况。
3. 在实际应用中，可以使用BufferedReader和BufferedWriter进行更高效的读取和写入操作。

扩展

• 可以考虑添加更多的功能，例如在复制前检查目标文件是否存在，是否覆盖等。
• 可以扩展为一个方法，接收源文件和目标文件的路径作为参数，以便复用。

OutputStream 类的常见API 

在Java中，OutputStream类是一个抽象类，主要用于输出字节流。常用的OutputStream子类包括FileOutputStream、BufferedOutputStream、DataOutputStream等。以下是一些常见的OutputStream类的方法：

1. 构造方法：

   • OutputStream()：创建一个新的OutputStream对象（需要子类实现具体功能）。

2. 写入字节：

   • void write(int b)：将指定的字节写入输出流。参数b可以是一个字节的值（0-255）。
   • void write(byte[] b)：将字节数组中的所有字节写入输出流。
   • void write(byte[] b, int off, int len)：将字节数组中从off（偏移量）开始的len（长度）个字节写入输出流。

3. 刷新：

   • void flush()：刷新输出流，确保所有缓冲的输出字节被写入目标流。

4. 关闭流：

   • void close()：关闭输出流并释放与之关联的所有资源。

5. 使用辅助功能（如在BufferedOutputStream中）：

   • void write(byte[] b, int off, int len)：也可以用于写入指定的字节数组部分。

示例代码

以下是一个简单示例，演示如何使用FileOutputStream写入字节到文件中：

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamExample {
    public static void main(String[] args) {
        // 使用FileOutputStream写入文件
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String content = "Hello, World!";
            fos.write(content.getBytes()); // 将字符串转换为字节并写入文件
            
            fos.flush(); // 刷新流，确保所有数据都被写入
            System.out.println("写入成功！"); // 提示消息
        } catch (IOException e) {
            System.out.println("写入失败：" + e.getMessage()); // 错误处理
        }
    }
}

通过使用OutputStream及其子类，可以方便地进行字节数据的输出操作，主要用于文件、网络等数据流的处理。

InputStream 类的常见API

在Java中，InputStream类是一个抽象类，主要用于输入字节流。常用的InputStream子类包括FileInputStream、BufferedInputStream、ByteArrayInputStream等。以下是一些常见的InputStream类的方法：

1. 构造方法：

   • InputStream()：创建一个新的InputStream对象（需要子类实现具体功能）。

2. 读取字节：

   • int read()：从输入流中读取下一个字节的数据，并返回（0-255）。如果到达流末尾，则返回-1。
   • int read(byte[] b)：从输入流中读取数量最多为b.length字节的数据到一个字节数组中，返回实际读取的字节数，返回-1表示到达流末尾。
   • int read(byte[] b, int off, int len)：从输入流中读取最多len字节的数据到字节数组b的指定偏移量off中，返回实际读取的字节数，返回-1表示到达流末尾。

3. 跳过字节：

   • long skip(long n)：跳过并丢弃n个字节，从输入流中返回实际跳过的字节数。

4. 可用字节：

   • int available()：返回可以从输入流中读取的字节数，而不需要阻塞。

5. 关闭流：

   • void close()：关闭输入流并释放与之关联的所有资源。

6. 标记和重置：

   • void mark(int readlimit)：标记当前输入流的位置，以便在读取数据后可以调用reset()方法返回到这个位置。
   • void reset()：重置输入流到最后标记的位置。
   • boolean markSupported()：检查该输入流是否支持标记和重置功能。

示例代码

以下是一个简单示例，演示如何使用FileInputStream读取文件内容：

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamExample {
    public static void main(String[] args) {
        // 使用FileInputStream读取文件
        try (FileInputStream fis = new FileInputStream("input.txt")) {
            int byteData;
            // 逐个字节读取文件内容
            while ((byteData = fis.read()) != -1) {
                System.out.print((char) byteData); // 将字节转换为字符并输出
            }
        } catch (IOException e) {
            System.out.println("读取失败：" + e.getMessage()); // 错误处理
        }
    }
}

通过使用InputStream及其子类，可以方便地进行字节数据的输入操作，主要用于文件、网络等数据流的处理。

InputStream & OutputStream 的格式化使用

InputStream

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;


public class InputStreamExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("./test.txt")) {
            Scanner scanner = new Scanner(inputStream);
            String s = scanner.next();
            System.out.println(s);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream

import java.io.*;


public class OutputStreamExample {
    public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("./test.txt")) {
            PrintWriter printWriter = new PrintWriter(outputStream);

            printWriter.println(2);

            printWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}