第八篇：Java I/O操作

HYP_Coder

于 2024-09-18 00:15:00 发布

阅读量1.1k

点赞数 33

分类专栏： JAVA专栏文章标签：开发语言 java 算法

本文链接：https://blog.csdn.net/HYP_Coder/article/details/142317967

版权

JAVA专栏专栏收录该内容

10 篇文章 0 订阅

订阅专栏

第八篇：Java I/O操作

Java的输入输出（I/O）操作是Java编程中至关重要的一部分。I/O操作涉及到数据的读写、文件操作、流处理等。理解Java I/O的基本概念和API有助于编写高效、健壮的数据处理程序。本篇文章将深入探讨Java中的I/O操作，包括输入和输出流、缓冲流和数据流以及对象序列化。

1. 输入和输出流

Java I/O操作基于流的概念。流是指数据的连续传输，Java中的流分为字节流和字符流两大类。

1.1 字节流和字符流

字节流和字符流是Java I/O操作中两种基本的数据传输方式。

1.1.1 字节流

字节流用于处理原始的二进制数据，它以字节为单位进行读写操作。字节流适合处理图片、音频、视频等非文本数据。Java中，字节流的主要基类是InputStream和OutputStream，其常用的子类包括：

FileInputStream：从文件中读取字节数据。
FileOutputStream：向文件中写入字节数据。
BufferedInputStream：提供对InputStream的缓冲支持，提高读取效率。
BufferedOutputStream：提供对OutputStream的缓冲支持，提高写入效率。

示例代码：使用FileInputStream和FileOutputStream进行文件的字节读写。

java

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

public class ByteStreamDemo {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int byteData;
            while ((byteData = fis.read()) != -1) {
                fos.write(byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java

1.1.2 字符流

字符流用于处理文本数据，它以字符为单位进行读写操作。字符流适合处理文本文件，能够处理字符编码。Java中，字符流的主要基类是Reader和Writer，其常用的子类包括：

FileReader：从文件中读取字符数据。
FileWriter：向文件中写入字符数据。
BufferedReader：为Reader提供缓冲支持，提供高效的字符读取功能。
BufferedWriter：为Writer提供缓冲支持，提供高效的字符写入功能。

示例代码：使用FileReader和FileWriter进行文件的字符读写。

java

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharStreamDemo {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt");
             FileWriter fw = new FileWriter("output.txt")) {
            int charData;
            while ((charData = fr.read()) != -1) {
                fw.write(charData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java

1.2 File类的使用

File类是Java中用于操作文件和目录的核心类。它提供了用于创建、删除、查询文件和目录等功能的方法。

1.2.1 文件和目录的基本操作

创建文件：使用createNewFile()方法创建新文件。
创建目录：使用mkdir()或mkdirs()方法创建新目录。
删除文件：使用delete()方法删除文件。
检查文件/目录是否存在：使用exists()方法检查文件或目录是否存在。
获取文件信息：使用length()方法获取文件大小，使用lastModified()方法获取最后修改时间。

示例代码：演示如何使用File类进行基本的文件操作。

java

import java.io.File;
import java.io.IOException;

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("example.txt");

        // 创建文件
        try {
            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 检查文件是否存在
        if (file.exists()) {
            System.out.println("File exists.");
            System.out.println("File size: " + file.length() + " bytes");
        }

        // 删除文件
        if (file.delete()) {
            System.out.println("File deleted: " + file.getName());
        } else {
            System.out.println("Failed to delete the file.");
        }

        // 创建目录
        File dir = new File("exampleDir");
        if (dir.mkdir()) {
            System.out.println("Directory created: " + dir.getName());
        }

        // 删除目录
        if (dir.delete()) {
            System.out.println("Directory deleted: " + dir.getName());
        }
    }
}

java

2. 缓冲流和数据流

缓冲流和数据流提供了对基本字节流和字符流的增强功能，以提高I/O操作的效率和灵活性。

2.1 BufferedReader和BufferedWriter

BufferedReader和BufferedWriter是字符流的缓冲实现，用于提高字符流的效率。它们在内存中使用缓冲区来存储数据，减少了实际的读写操作次数，从而提高了性能。

2.1.1 BufferedReader

BufferedReader用于从字符输入流中高效地读取文本。它提供了readLine()方法，可以一次读取一行文本。

示例代码：使用BufferedReader读取文件内容。

java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java

2.1.2 BufferedWriter

BufferedWriter用于将字符数据高效地写入输出流。它提供了newLine()方法，用于在写入时插入平台相关的换行符。

示例代码：使用BufferedWriter将内容写入文件。

java

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, World!");
            bw.newLine();
            bw.write("Java I/O operations.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java

2.2 DataInputStream和DataOutputStream

DataInputStream和DataOutputStream用于读写基本数据类型（如int、float、double等）。它们提供了将数据读写到流中并保留其类型信息的能力。

2.2.1 DataInputStream

DataInputStream用于从输入流中读取基本数据类型数据，并按照原始的字节序列读取数据。

示例代码：使用DataInputStream读取数据。

java

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

public class DataInputStreamDemo {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.dat"))) {
            int intData = dis.readInt();
            double doubleData = dis.readDouble();
            System.out.println("Read int: " + intData);
            System.out.println("Read double: " + doubleData);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java

2.2.2 DataOutputStream

DataOutputStream用于将基本数据类型数据写入输出流中。它可以将数据以原始字节序列的形式写入流。

示例代码：使用DataOutputStream写入数据。

java

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

public class DataOutputStreamDemo {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.dat"))) {
            dos.writeInt(123);
            dos.writeDouble(456.78);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java

3. 对象序列化

对象序列化是将对象的状态转换为字节流的过程，这样可以将对象保存到文件中或通过网络传输。反序列化是将字节流

转换回对象的过程。Java提供了机制来支持对象的序列化和反序列化，使得对象能够在不同的环境中持久化和传输。

3.1 序列化的概念

序列化是将对象的状态转换为字节流的过程，这些字节流可以存储到文件中、传输到网络上，或者在Java虚拟机之间进行交换。反序列化则是将字节流还原为对象的过程。序列化和反序列化是Java提供的持久化机制之一，它们在分布式应用程序、数据存储等方面有广泛的应用。

3.1.1 序列化的过程

序列化：将对象的状态写入流中，这样对象的状态可以在未来的某个时刻恢复。ObjectOutputStream用于序列化对象。
反序列化：从流中读取对象的状态，并恢复到内存中。ObjectInputStream用于反序列化对象。

3.2 实现Serializable接口

要使一个Java对象能够被序列化，它的类必须实现java.io.Serializable接口。Serializable是一个标记接口，它没有任何方法，只是标识一个类可以被序列化。

3.2.1 实现Serializable接口

一个类实现Serializable接口之后，其对象可以被序列化。以下是一个示例：

java

import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L; // 推荐的序列化版本号
    private String name;
    private transient int age; // transient修饰符表示不序列化该字段

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

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

public class SerializationDemo {
    public static void main(String[] args) {
        Person person = new Person("John Doe", 30);

        // 序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("Deserialized Person: " + deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

java

3.2.2 处理序列化版本号

在序列化过程中，serialVersionUID是一个重要的字段，它用于验证序列化版本的兼容性。如果序列化和反序列化的类版本不匹配，系统将抛出InvalidClassException。建议在每个序列化的类中定义serialVersionUID，以确保序列化和反序列化的兼容性。

java

private static final long serialVersionUID = 1L;

3.2.3 transient关键字

在类中，如果某些字段不需要序列化，可以使用transient关键字修饰。被transient修饰的字段在序列化时不会被写入流中，也不会在反序列化时恢复。

java

private transient int age; // 不被序列化的字段

3.2.4 自定义序列化

有时候需要在序列化和反序列化过程中执行自定义操作。例如，可以通过实现writeObject()和readObject()方法来控制序列化和反序列化的过程。

java

import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient int age;

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

    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject(); // 默认序列化
        oos.writeInt(age); // 自定义序列化
    }

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject(); // 默认反序列化
        age = ois.readInt(); // 自定义反序列化
    }

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

java