java文件与IO_java io包中可以用于从文件中直接读取字符的类是什么-CSDN博客

本文链接：https://blog.csdn.net/m0_56224451/article/details/133275698

Java 提供了丰富的类和接口来处理文件和 I/O 操作。

下面是 Java 中常用的文件和 I/O 相关的类与 API 的概述：

File 类：File 类提供了用于操作文件和目录的方法，如创建、删除、重命名、判断是否存在等。它可以表示文件或目录的路径，但不提供读写文件内容的方法。
InputStream 和 OutputStream 类：InputStream 和 OutputStream 是字节流的抽象类，用于读取和写入字节数据。常见的子类有 FileInputStream、FileOutputStream，用于文件的字节读写操作。
Reader 和 Writer 类：Reader 和 Writer 是字符流的抽象类，用于读取和写入字符数据。常见的子类有 FileReader、FileWriter，用于文件的字符读写操作。
BufferedReader 和 BufferedWriter 类：BufferedReader 和 BufferedWriter 是字符流的缓冲区处理类，提供了高效的读取和写入方法。
Scanner 类：Scanner 类可以方便地从输入流中读取各种类型的数据，如整数、浮点数、字符串等。
RandomAccessFile 类：RandomAccessFile 类允许以随机方式访问文件内容，可以在文件的任意位置读写数据。
FileDescriptor 类：FileDescriptor 类表示文件描述符，可用于在底层操作系统上直接操作文件。
ObjectOutputStream 和 ObjectInputStream 类：ObjectOutputStream 和 ObjectInputStream 类提供了对象的序列化和反序列化功能，用于将对象写入文件或从文件中读取对象。
NIO（New I/O）包：Java NIO 提供了基于通道（Channel）和缓冲区（Buffer）的高性能 I/O 操作方式。常见的类包括 ByteBuffer、FileChannel、SocketChannel、Selector 等。

上述类和接口为 Java 文件和 I/O 操作提供了丰富的功能和灵活性。根据具体的需求，可以选择合适的类和方法来进行文件的读写、复制、移动、目录的遍历等操作。在使用这些类时，要注意正确地处理异常，并释放资源以避免资源泄露。

File 类

File 类是 Java 中用于操作文件和目录的核心类。它可以表示文件路径或目录路径，并且提供了一系列方法来进行文件和目录的创建、删除、重命名等操作。

以下是 File 类常用方法的介绍以及使用 Java 代码的示例：

File(String path)：通过给定的路径创建一个 File 对象。

String filePath = "C:/path/to/file.txt";
File file = new File(filePath);

boolean exists()：判断文件或目录是否存在。

if (file.exists()) {
    System.out.println("文件存在");
} else {
    System.out.println("文件不存在");
}

boolean isFile()：判断当前 File 对象是否表示一个文件。

if (file.isFile()) {
    System.out.println("这是一个文件");
} else {
    System.out.println("这不是一个文件");
}

boolean isDirectory()：判断当前 File 对象是否表示一个目录。

if (file.isDirectory()) {
    System.out.println("这是一个目录");
} else {
    System.out.println("这不是一个目录");
}

String getName()：获取文件或目录的名称。

String fileName = file.getName();
System.out.println("文件名：" + fileName);

String getPath()：获取文件或目录的路径。

String filePath = file.getPath();
System.out.println("文件路径：" + filePath);

File[] listFiles()：获取目录下的所有文件和子目录。

if (file.isDirectory()) {
    File[] files = file.listFiles();
    for (File f : files) {
        System.out.println("文件名：" + f.getName());
    }
}

boolean createNewFile()：在指定路径下创建一个新文件。

try {
    boolean success = file.createNewFile();
    if (success) {
        System.out.println("文件创建成功");
    } else {
        System.out.println("文件创建失败");
    }
} catch (IOException e) {
    e.printStackTrace();
}

boolean mkdir()：在指定路径下创建一个新目录。

boolean success = file.mkdir();
if (success) {
    System.out.println("目录创建成功");
} else {
    System.out.println("目录创建失败");
}

boolean delete()：删除文件或目录。

boolean success = file.delete();
if (success) {
    System.out.println("文件删除成功");
} else {
    System.out.println("文件删除失败");
}

boolean renameTo(File dest)：重命名文件或目录。

String newFilePath = "C:/path/to/newfile.txt";
File newFile = new File(newFilePath);
boolean success = file.renameTo(newFile);
if (success) {
    System.out.println("文件重命名成功");
} else {
    System.out.println("文件重命名失败");
}

这些方法只是 File 类提供的一部分常用方法，通过这些方法可以完成文件和目录的基本操作。要注意的是，某些操作需要权限或文件存在才能执行成功，在使用这些方法时需注意异常处理。

InputStream 和 OutputStream 类

InputStream 和 OutputStream 是 Java 中用于字节流读取和写入操作的抽象类。它们是许多其他具体流类的基类，如 FileInputStream、FileOutputStream 等，用于对文件进行字节级别的读取和写入操作。

以下是 InputStream 和 OutputStream 类的详细介绍，并给出了一些使用 Java 代码的示例：

InputStream 类：

InputStream 是所有输入流的抽象父类，它定义了读取字节数据的基本方法。
常用的子类包括 FileInputStream、ByteArrayInputStream 等。

示例代码：

// 使用 FileInputStream 读取文件中的字节数据
String filePath = "C:/path/to/file.txt";
try (InputStream inputStream = new FileInputStream(filePath)) {
    int data;
    while ((data = inputStream.read()) != -1) {
        // 处理读取到的字节数据
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

OutputStream 类：

OutputStream 是所有输出流的抽象父类，它定义了写入字节数据的基本方法。
常用的子类包括 FileOutputStream、ByteArrayOutputStream 等。

示例代码：

// 使用 FileOutputStream 写入字节数据到文件中
String filePath = "C:/path/to/newfile.txt";
try (OutputStream outputStream = new FileOutputStream(filePath)) {
    String text = "Hello, World!";
    byte[] byteArray = text.getBytes();
    outputStream.write(byteArray);
} catch (IOException e) {
    e.printStackTrace();
}

共同的方法和概念：
- InputStream 和 OutputStream 类都提供了 close() 方法，用于关闭流并释放资源。
- 它们都支持基本的字节读取和写入操作，如 read()、write(byte[])、skip(long) 等。
- 为了提高性能，通常会使用缓冲流（如 BufferedInputStream 和 BufferedOutputStream）对其进行包装，以减少频繁的 IO 操作。

请注意，在使用这些类进行文件读写操作时，需要进行适当的异常处理，并在使用完后及时关闭流以释放资源。

Reader 和 Writer 类

当需要以字符为单位进行读写操作时，可以使用 Java 中的 Reader 和 Writer 类，它们是字符流的抽象父类。下面将详细介绍这两个类，并给出使用示例。

Reader 类：

Reader 是所有字符输入流的抽象类，用于读取字符数据。以下是一些常用的子类：

FileReader：用于从文件中读取字符数据。它会打开一个文件，并按字符顺序读取文件内容。示例代码如下：

String filePath = "C:/path/to/file.txt";
try (Reader reader = new FileReader(filePath)) {
    int data;
    while ((data = reader.read()) != -1) {
        // 处理读取到的字符数据
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

StringReader：用于从字符串中读取字符数据。可以将字符串作为输入源进行读取操作。示例代码如下：

String text = "Hello, World!";
try (Reader reader = new StringReader(text)) {
    int data;
    while ((data = reader.read()) != -1) {
        // 处理读取到的字符数据
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

Writer 类：

Writer 是所有字符输出流的抽象类，用于写入字符数据。以下是一些常用的子类：

FileWriter：用于向文件中写入字符数据。它会创建一个新文件，并按字符顺序写入内容。示例代码如下：

String filePath = "C:/path/to/newfile.txt";
try (Writer writer = new FileWriter(filePath)) {
    String text = "Hello, World!";
    writer.write(text);
} catch (IOException e) {
    e.printStackTrace();
}

StringWriter：用于将字符数据写入字符串。可以创建一个内存缓冲区，将字符数据写入其中。示例代码如下：

try (Writer writer = new StringWriter()) {
    String text = "Hello, World!";
    writer.write(text);
    
    // 从 StringWriter 中获取写入的字符数据
    String outputText = writer.toString();
    System.out.println(outputText); // 输出 "Hello, World!"
} catch (IOException e) {
    e.printStackTrace();
}

这些子类提供了不同的方式来读取和写入字符数据，可以根据具体需求选择合适的子类。无论是从文件读取字符数据还是将字符数据写入文件，都可以使用这些类来完成操作。

BufferedReader 和 BufferedWriter 类

当需要高效读取和写入字符数据时，可以使用 Java 中的 BufferedReader 和 BufferedWriter 类。它们是字符流的缓冲区处理类，可以提供更快速的读写操作。下面将详细介绍这两个类，并给出使用示例。

BufferedReader 类：
- BufferedReader 是字符输入流的缓冲区处理类，用于高效读取字符数据。它可以提供一次读取多个字符的能力，减少了频繁读取的开销。以下是一个使用示例：
```
String filePath = "C:/path/to/file.txt";
try (Reader reader = new FileReader(filePath);
     BufferedReader bufferedReader = new BufferedReader(reader)) {
    String line;
    while ((line = bufferedReader.readLine()) != null) {
        // 处理读取到的每一行字符数据
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}
```
在上述示例中，通过将 FileReader 包装在 BufferedReader 中，可以逐行读取文件内容并进行处理。readLine() 方法用于一次读取一行数据，直到返回 null 表示所有数据读取完毕。
BufferedWriter 类：
- BufferedWriter 是字符输出流的缓冲区处理类，用于高效写入字符数据。它可以提供一次写入多个字符的能力，减少了频繁写入的开销。以下是一个使用示例：
```
String filePath = "C:/path/to/newfile.txt";
try (Writer writer = new FileWriter(filePath);
     BufferedWriter bufferedWriter = new BufferedWriter(writer)) {
    String text = "Hello, World!";
    bufferedWriter.write(text);
} catch (IOException e) {
    e.printStackTrace();
}
```
在上述示例中，通过将 FileWriter 包装在 BufferedWriter 中，可以一次性将字符数据写入文件。write() 方法用于写入字符数据。

这些缓冲区处理类可以提高读写效率，特别适用于大量字符数据的读写操作。另外，在使用完毕后，需要及时关闭流以释放资源。

Scanner 类

Scanner 类是 Java 的一个实用工具类，提供了方便的方法来从输入流中读取各种类型的数据，如整数、浮点数、字符串等。它可以从标准输入、文件或其他输入源读取数据。下面将详细介绍 Scanner 类，并给出使用示例。

创建 Scanner 对象：
- 若要创建一个 Scanner 对象，需要将要读取的输入流作为构造函数的参数。以下是一些常见的使用方式：
  - 从标准输入读取数据：使用 System.in 作为构造函数的参数。
```
Scanner scanner = new Scanner(System.in);
```
  - 从文件读取数据：使用 File 对象作为构造函数的参数。
```
File file = new File("C:/path/to/file.txt");
Scanner scanner = new Scanner(file);
```
使用 Scanner 对象读取数据：
- Scanner 类提供了多个方法用于读取不同类型的数据。以下是一些常用的方法：
  - nextInt()：读取一个整数。
  - nextFloat()：读取一个浮点数。
  - nextDouble()：读取一个双精度浮点数。
  - nextLine()：读取一行字符串。
  - next()：读取一个单词（以空格分隔）。
  - hasNextXXX()：检查是否还有下一个指定类型的数据。
下面是一个示例代码，演示了如何使用 Scanner 类从标准输入读取数据：
```
import java.util.Scanner;

public class ScannerExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个整数：");
        int num = scanner.nextInt();
        System.out.println("您输入的整数是：" + num);

        System.out.print("请输入一个浮点数：");
        float decimal = scanner.nextFloat();
        System.out.println("您输入的浮点数是：" + decimal);

        System.out.print("请输入一行字符串：");
        String text = scanner.nextLine();
        System.out.println("您输入的字符串是：" + text);

        scanner.close();
    }
}
```
在上述示例中，通过 Scanner 对象的不同方法，我们可以方便地读取用户输入的整数、浮点数和字符串。需要注意的是，在使用完 Scanner 对象后，要及时调用 close() 方法关闭流，以释放资源。

ObjectOutputStream 和 ObjectInputStream 类

ObjectOutputStream 和 ObjectInputStream 是 Java 提供的用于对象序列化和反序列化的类。它们可以将对象转换为字节流进行持久化存储或网络传输，并能够将字节流转换回原始对象。下面将详细介绍 ObjectOutputStream 和 ObjectInputStream 类，并给出使用示例。

ObjectOutputStream 类：
- ObjectOutputStream 类用于将对象序列化为字节流。它提供了一些方法来将对象写入输出流中，并支持对象图的持久化。以下是一些常用的方法：
  - writeObject(Object obj)：将对象写入输出流。
  - flush()：刷新输出流，确保所有缓冲的数据被写入。
  - close()：关闭输出流。
ObjectInputStream 类：
- ObjectInputStream 类用于从字节流中反序列化对象。它提供了一些方法来从输入流中读取对象，并将字节流转换为原始对象。以下是一些常用的方法：
  - readObject()：从输入流中读取对象。
  - close()：关闭输入流。

下面是一个示例代码，演示了如何使用 ObjectOutputStream 和 ObjectInputStream 类进行对象的序列化和反序列化：

import java.io.*;

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class ObjectStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/path/to/person.ser";

        // 对象序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) {
            Person person = new Person("Alice", 25);
            oos.writeObject(person);
            oos.flush();
            System.out.println("对象序列化成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 对象反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath))) {
            Person person = (Person) ois.readObject();
            System.out.println("姓名：" + person.getName());
            System.out.println("年龄：" + person.getAge());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，我们定义了一个 Person 类，并实现了 Serializable 接口，以便对象可以被序列化。然后，我们使用 ObjectOutputStream 类将 Person 对象写入文件（序列化），并使用 ObjectInputStream 类从文件中读取对象（反序列化）。最后，我们输出了反序列化后的对象的姓名和年龄。

需要注意的是，被序列化的类必须实现 Serializable 接口，否则在序列化时会抛出 NotSerializableException 异常。

总结

Java 中的文件和 I/O（Input/Output，输入/输出）是与外部数据交互和持久化存储有关的重要方面。以下是 Java 中文件和 I/O 的简要总结：

文件操作：
- Java 中的文件操作通常涉及到读取和写入文件，以及文件和目录的创建、删除和重命名等。
- 主要的文件操作类包括 File 类和 Files 类。File 类用于处理文件和目录的基本操作，而 Files 类提供了更强大的文件处理方法。
输入和输出流：
- Java 中的 I/O 通常通过输入流（InputStream 和 Reader）和输出流（OutputStream 和 Writer）进行。这些流可用于从文件、网络、标准输入/输出等获取或写入数据。
- 例子包括 FileInputStream、FileOutputStream、BufferedReader、BufferedWriter 等。
字符流和字节流：
- 字节流（Byte Streams）主要用于处理二进制数据，适用于处理图像、音频、视频等。例如，FileInputStream 和 FileOutputStream。
- 字符流（Character Streams）用于处理文本数据，提供了字符编码的支持，适用于文本文件的读写。例如，FileReader 和 FileWriter。
缓冲流：
- 缓冲流（Buffered Streams）提供了缓冲区，可以提高 I/O 操作的性能。通常，使用 BufferedReader 和 BufferedWriter 来读写文件更加高效。
序列化和反序列化：
- Java 支持对象的序列化，即将对象转换为字节流以便持久化存储或传输。反序列化是将字节流还原为对象。
- 用于序列化的主要类是 ObjectOutputStream 和 ObjectInputStream。
NIO（New I/O）：
- Java 1.4 引入了 NIO，提供了更强大和高性能的 I/O 操作。主要类包括 ByteBuffer、Channel、Selector 等。
- NIO 提供了非阻塞 I/O 操作，适用于高并发应用。
文件操作异常处理：
- 在文件和 I/O 操作中，需要处理各种异常情况，如文件不存在、权限问题、读写错误等。通常使用异常处理机制来应对这些问题。
自动资源管理（try-with-resources）：
- Java 7 引入了自动资源管理，使用 try-with-resources 语句可以自动关闭资源，如文件流，以确保资源得到正确释放。