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语句可以自动关闭资源，如文件流，以确保资源得到正确释放。
-
以上是 Java 中文件和 I/O 的主要概念和类别。
1833
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
