Java ObjectInputStream Class

2025年5月9日 | 阅读 12 分钟

java.io.ObjectInputStream 类用于反序列化先前使用 ObjectOutputStream 序列化的对象和原始数据。它允许重建对象图，并确保序列化对象的类与当前 JVM (Java 虚拟机) 的类定义兼容。

ObjectOutputStream 和 ObjectInputStream 协同工作以保存和访问对象图。尽管如此，只有实现 Serializable 或 Externalizable 接口的项才能从流中检索。如果找到不可序列化的项，将发生错误。Serializable 接口充当标记，指示 JVM 将对象的当前状态记录到流中。

类声明

public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants   

构造函数

protected ObjectInputStream(): 此构造方法用于允许子类在不分配其私有数据的情况下重新实现 ObjectInputStream。
ObjectInputStream(InputStream in): 它创建一个 ObjectInputStream，用于从指定的输入流 (in) 读取数据。

ObjectOutputStream 类的方法

read() 方法

java.io.ObjectInputStream 的 read() 方法从流中读取一个字节的数据，如果没有可用数据则会阻塞。

语法

参数

无。

返回值

返回读取的字节数据，如果到达流的末尾则返回 -1。

异常

IOException：如果发生 I/O 错误，则抛出此异常。

readBoolean() 方法

java.io.ObjectInputStream 的 readBoolean() 方法从流中读取一个布尔值。

语法

参数

无。

返回值

返回从流中读取的布尔值。

异常

IOException：如果发生 I/O 错误，则抛出此异常。
EOFException：如果意外到达流的末尾，则抛出此异常。

import java.io.*;  
public class ObjectInputStreamExample {
    public static void main(String[] args) {
        // Write data to file using ObjectOutputStream
        try {
            // Creating a FileOutputStream to write to a file named "data.ser"
            FileOutputStream fileOut = new FileOutputStream("data.ser");
            // Creating an ObjectOutputStream to write objects to the file
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // Writing a byte value (ASCII value of 'A') to the file
            out.writeByte(65);  // 65 corresponds to 'A' in ASCII
            // Writing a boolean value (true) to the file
            out.writeBoolean(true);  // true is written to the file
            // Closing the ObjectOutputStream
            out.close();
            // Closing the FileOutputStream
            fileOut.close();
        } catch (IOException e) {
            // Handling any IOExceptions that might occur
            e.printStackTrace();
        }
        // Read data from file using ObjectInputStream
        try {
            // Creating FileInputStream to read data from the "data.ser" file
            FileInputStream fileIn = new FileInputStream("data.ser");
            // Creating ObjectInputStream to read objects from the file
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // Reading a byte value from the file using the read() method
            int byteData = in.read();  // Reads the byte (65, which represents 'A')
            // Printing the byte data as a character
            System.out.println("Byte value read: " + (char) byteData);  // Converts 65 to 'A' and prints it
            // Reading a boolean value from the file using the readBoolean() method
            boolean boolData = in.readBoolean();  // Reads the boolean value (true)
            // Printing the boolean data
            System.out.println("Boolean value read: " + boolData);  // Prints 'true'
            // Closing the ObjectInputStream
            in.close();
            // Closing the FileInputStream
            fileIn.close();
        } catch (IOException e) {
            // Handling any IOExceptions that might occur while reading data
            e.printStackTrace();
        }
    }
}   

输出

 
Byte value read: A
Boolean value read: true

read(byte[] buffer, int offset, int maxlen) 方法

java.io.ObjectInputStream 的 read(byte[] buffer, int offset, int maxlen) 方法从输入流中读取指定数量的字节到字节数组中。

语法

参数

buffer: 数据将存储的字节数组。
offset: 数据将存储在字节数组中的起始位置。
maxlen: 要读取的最大字节数。

返回值

实际读取的字节数。
如果到达流的末尾，则返回 -1。

异常

IOException： 如果在读取过程中发生 I/O 错误，则抛出此异常。

import java.io.*;
public class ReadByteArrayExample {
    public static void main(String[] args) {
        // Writing data to a file
        try {
            // Creating FileOutputStream to write to "data.ser"
            FileOutputStream fileOut = new FileOutputStream("data.ser");
            // Creating ObjectOutputStream to write objects and data to the file
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // Writing a string as bytes
            out.write("Hello, World!".getBytes());
            // Closing streams
            out.close();
            fileOut.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // Reading data from the file
        try {
            // Creating FileInputStream to read from "data.ser"
            FileInputStream fileIn = new FileInputStream("data.ser");
            // Creating ObjectInputStream to read objects and data
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // Creating a byte array buffer to store the data
            byte[] buffer = new byte[20];  
            int bytesRead = in.read(buffer, 0, buffer.length); 
            // Printing the number of bytes read
            System.out.println("Bytes read: " + bytesRead);
            // Converting and printing the byte data as a String
            System.out.println("Data read: " + new String(buffer, 0, bytesRead));
            // Closing streams
            in.close();
            fileIn.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}   

输出

 
Bytes read: 13
Data read: Hello, World!

readByte() 方法

java.io.ObjectInputStream 类的 readByte() 方法从输入流中读取一个 8 位字节。

语法

参数

无。

返回值

返回一个 8 位有符号整数形式的字节值（-128 到 127）。

异常

IOException： 如果在读取过程中发生 I/O 错误，则抛出此异常。
EOFException： 如果意外到达流的末尾，则抛出此异常。

readChar() 方法

从流中读取单个 16 位 Unicode 字符。

语法

返回值： 字符值。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果到达流的末尾。

readDouble() 方法

从流中读取一个 8 字节（64 位）的 double 值。

语法

返回值： double 值。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果到达流的末尾。

readFloat() 方法

从流中读取一个 4 字节（32 位）的浮点值。

语法

返回值： float 值。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果到达流的末尾。

readInt() 方法

从流中读取一个 4 字节（32 位）的整数值。

语法

返回值： int 值。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果到达流的末尾。

readLong() 方法

从流中读取一个 8 字节（64 位）的 long 值。

语法

返回值： long 值。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果到达流的末尾。

import java.io.*;
public class ObjectStreamExample {
    public static void main(String[] args) {
        // Writing data to a file
        try {
            // Step 1: Create FileOutputStream to write to a file
            FileOutputStream fileOut = new FileOutputStream("data.ser");
            // Step 2: Wrap it in ObjectOutputStream for object data
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // Writing various data types to the stream
            out.writeChar('Z');         // Writing a character
            out.writeByte(127);         // Writing a byte
            out.writeDouble(1234.56);   // Writing a double value
            out.writeFloat(12.34f);     // Writing a float value
            out.writeInt(100);          // Writing an integer
            out.writeLong(123456789L);  // Writing a long value
            // Close the output streams
            out.close();
            fileOut.close();
            System.out.println("Data written to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
        // Reading data from the file
        try {
            // Step 1: Create FileInputStream to read from the file
            FileInputStream fileIn = new FileInputStream("data.ser");
            // Step 2: Wrap it in ObjectInputStream for object data
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // Reading the data in the same order it was written
            char charValue = in.readChar();           // Reading a character
            byte byteValue = in.readByte();           // Reading a byte
            double doubleValue = in.readDouble();     // Reading a double
            float floatValue = in.readFloat();        // Reading a float
            int intValue = in.readInt();              // Reading an integer
            long longValue = in.readLong();           // Reading a long
            // Print the read values
            System.out.println("Character read: " + charValue);
            System.out.println("Byte read: " + byteValue);
            System.out.println("Double read: " + doubleValue);
            System.out.println("Float read: " + floatValue);
            System.out.println("Integer read: " + intValue);
            System.out.println("Long read: " + longValue);
            // Close the input streams
            in.close();
            fileIn.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}   

输出

 
Data written to file successfully.
Character read: Z
Byte read: 127
Double read: 1234.56
Float read: 12.34
Integer read: 100
Long read: 123456789

readUnsignedByte() 方法

从流中读取一个 8 位无符号字节，并将其作为整数值返回。

语法

返回值

一个 0 到 255 范围内的 int。

异常

IOException： 如果发生 I/O 错误。

readUnsignedShort() 方法

从流中读取一个 16 位无符号 short，并将其作为整数值返回。

语法

返回值

一个 0 到 65535 范围内的 int。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果到达流的末尾。

import java.io.*; 
public class UnsignedDataExample {
    public static void main(String[] args) {
        // Writing data to a file
        try {
            // Step 1: Create a FileOutputStream to write data to a file named "unsignedData.ser"
            FileOutputStream fileOut = new FileOutputStream("unsignedData.ser");
            // Step 2: Wrap the FileOutputStream with ObjectOutputStream to write objects and primitive data types
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // Write an unsigned byte (200). Since Java uses signed bytes, this will be stored as -56
            out.writeByte(200);
            // Write an unsigned short (60000). Since Java uses signed shorts, this will be stored as -5536
            out.writeShort(60000);
            // Close the ObjectOutputStream to release resources
            out.close();
            // Close the FileOutputStream to release resources
            fileOut.close();
            // Inform the user that data has been written successfully
            System.out.println("Data written to file successfully.");
        } catch (IOException e) {
            // Handle any IOException that may occur during the writing process
            e.printStackTrace();
        }
        // Reading data from the file
        try {
            // Step 1: Create a FileInputStream to read data from the file named "unsignedData.ser"
            FileInputStream fileIn = new FileInputStream("unsignedData.ser");
            // Step 2: Wrap the FileInputStream with ObjectInputStream to read objects and primitive data types
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // Read the unsigned byte from the file and interpret it as an integer (0 to 255)
            int unsignedByteValue = in.readUnsignedByte();
            // Read the unsigned short from the file and interpret it as an integer (0 to 65535)
            int unsignedShortValue = in.readUnsignedShort();
            // Print the unsigned byte value read from the file
            System.out.println("Unsigned Byte read: " + unsignedByteValue);
            // Print the unsigned short value read from the file
            System.out.println("Unsigned Short read: " + unsignedShortValue);
            // Close the ObjectInputStream to release resources
            in.close();
            // Close the FileInputStream to release resources
            fileIn.close();
        } catch (IOException e) {
            // Handle any IOException that may occur during the reading process
            e.printStackTrace();
        }
    }
}   

输出

 
Data written to file successfully.
Unsigned Byte read: 200
Unsigned Short read: 60000

readUTF() 方法

ObjectInputStream 类中的 readUTF() 方法用于读取使用修改后的 UTF-8 格式编码的字符串。它通常用于读取 ObjectOutputStream 的 writeUTF() 方法写入的字符串。

语法

描述

读取使用修改后的 UTF-8 格式编码的字符串。
此方法确保在读取 writeUTF() 写入的字符串时具有兼容性。

返回值

该方法返回从流中读取的 String。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果在读取完整字符串之前到达流的末尾。
UTFDataFormatException： 如果 UTF-8 数据格式错误。

文件名：UTFReadExample.java

import java.io.*;
public class UTFReadExample {
    public static void main(String[] args) throws IOException {
        // Create a file to store data and setup output and input streams
        FileOutputStream fileOutput = new FileOutputStream("example.txt");
        ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutput);
        // Create an ObjectInputStream to read from the same file
        ObjectInputStream objectInput = new ObjectInputStream(new FileInputStream("example.txt"));
        // Write a UTF-encoded string to the file
        objectOutput.writeUTF("LearningWithExamples");
        objectOutput.flush(); // Ensure all data is written to the file
        // Read and display the UTF string from the file
        System.out.println("Result from readUTF(): " + objectInput.readUTF());
        // Close the streams to release resources
        objectOutput.close();
        objectInput.close();
    }
}   

输出

 
Result from readUTF(): LearningWithExamples

skipBytes(int maxlen) 方法

ObjectInputStream 中的 skipBytes(int n) 方法用于跳过输入流中指定数量的字节。当您想在读取时绕过数据的某些部分时，此方法特别有用。

语法

参数

n: 要跳过的字节数。

返回值

实际跳过的字节数，如果到达文件末尾之前跳过的字节数少于 n，则可能小于 n。

异常

IOException： 如果在跳过字节时发生 I/O 错误。

import java.io.*;
public class SkipBytesExample {
    public static void main(String[] args) throws IOException {
        // Create a file and setup ObjectOutputStream to write to it
        FileOutputStream fileOutput = new FileOutputStream("example.txt");
        ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutput);
        // Write data to the file
        objectOutput.writeUTF("LearningBytesHere");
        objectOutput.flush(); // Ensure data is written to the file
        // Setup ObjectInputStream to read from the file
        ObjectInputStream objectInput = new ObjectInputStream(new FileInputStream("example.txt"));
        // Skip the first 7 bytes in the file
        objectInput.skipBytes(7);
        // Read and print the remaining bytes in the file
        while (objectInput.available() > 0) {
            System.out.print((char) objectInput.readByte());
        }
        // Close the streams
        objectOutput.close();
        objectInput.close();
    }
}   

输出

 
ingBytesHere

readFully(byte[] destination) 方法

ObjectInputStream 类中的 readFully(byte[] destination) 方法从输入流中读取数据并完全填充提供的字节数组。此方法会阻塞，直到读取完数组中的所有字节或抛出异常。

语法

参数

destination: 数据将存储的字节数组。

返回值

此方法不返回值，因为它直接将数据写入提供的字节数组。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果在读取指定数量的字节之前到达流的末尾。

import java.io.*;
public class ReadFullyExample {
    public static void main(String[] args) {
        try {
            // Create a file and write data to it using ObjectOutputStream
            FileOutputStream fileOutput = new FileOutputStream("data.bin");
            ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutput);
            // Write a string in bytes to the file
            objectOutput.writeUTF("JavaIsAwesome");
            objectOutput.flush();
            objectOutput.close();
            // Prepare to read data back using ObjectInputStream
            FileInputStream fileInput = new FileInputStream("data.bin");
            ObjectInputStream objectInput = new ObjectInputStream(fileInput);
            // Create a byte array to hold the data
            byte[] buffer = new byte[15]; // Adjust size as needed
            // Use readFully to fill the byte array
            objectInput.readFully(buffer);
            // Convert byte array to string and print the result
            String result = new String(buffer);
            System.out.println("Data read using readFully: " + result);
            // Close the input stream
            objectInput.close();
        } catch (EOFException e) {
            System.out.println("Reached the end of the file before reading fully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}   

输出

 
Data read using readFully: JavaIsAwesome

readFully(byte[] destination, int offset, int maxlen) 方法

ObjectInputStream 类中的 readFully(byte[] destination, int offset, int maxlen) 方法从输入流中读取指定数量的字节，并将它们写入提供的字节数组的特定部分。此方法会阻塞，直到完全读取请求的字节或抛出异常。

语法

public void readFully(byte[] destination, int offset, int maxlen) throws IOException   

参数

destination: 数据将存储的字节数组。
offset: 数组中开始写入数据的起始位置。
maxlen: 要从输入流中读取的字节数。

异常

IOException： 如果发生 I/O 错误。
EOFException： 如果在读取指定数量的字节之前到达流的末尾。
IndexOutOfBoundsException： 如果指定的偏移量和长度超出了字节数组的大小。

文件名：ReadFullyWithOffsetExample.java

import java.io.*;
public class ReadFullyWithOffsetExample {
    public static void main(String[] args) {
        try {
            // Create a file output stream to write data to a file
            FileOutputStream fileOutput = new FileOutputStream("data_with_offset.bin");
            // Wrap the FileOutputStream with an ObjectOutputStream for writing objects
            ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutput);
            // Write a UTF string to the file using ObjectOutputStream
            objectOutput.writeUTF("HelloWorldBytes");
            // Flush the ObjectOutputStream to ensure all data is written to the file
            objectOutput.flush();
            // Close the ObjectOutputStream after writing is complete
            objectOutput.close();
            // Create a file input stream to read data from the file
            FileInputStream fileInput = new FileInputStream("data_with_offset.bin");
            // Wrap the FileInputStream with an ObjectInputStream for reading objects
            ObjectInputStream objectInput = new ObjectInputStream(fileInput);
            // Create a byte array to store the data being read
            byte[] buffer = new byte[20]; // The array size should be large enough for the operation
            // Read 5 bytes starting from the 3rd byte of the file
            // and store them starting at position 2 in the buffer array
            objectInput.readFully(buffer, 2, 5);
            // Print the buffer content to verify the data read
            System.out.println("Buffer content:");
            for (int i = 0; i < buffer.length; i++) {
                // Print each character in the buffer
                // Empty/default array slots will print as blank or unprintable characters
                System.out.print((char) buffer[i]);
            }
            // Close the ObjectInputStream after reading is complete
            objectInput.close();
        } catch (EOFException e) {
            // Handle the case where the end of the file is reached before all data is read
            System.out.println("Reached the end of the file before reading fully.");
        } catch (IOException e) {
            // Handle other I/O errors
            e.printStackTrace();
        }
    }
}   

输出

 
Buffer content:
  H  e  l  l  o

下一个主题Java 框架

← 上一个下一个 →

Java ObjectInputStream Class

ObjectOutputStream 类的方法

read() 方法

readBoolean() 方法

read(byte[] buffer, int offset, int maxlen) 方法

readByte() 方法

readChar() 方法

readDouble() 方法

readFloat() 方法

readInt() 方法

readLong() 方法

readUnsignedByte() 方法

readUnsignedShort() 方法

readUTF() 方法

skipBytes(int maxlen) 方法

readFully(byte[] destination) 方法

readFully(byte[] destination, int offset, int maxlen) 方法

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java ObjectInputStream Class

ObjectOutputStream 类的方法

read() 方法

readBoolean() 方法

read(byte[] buffer, int offset, int maxlen) 方法

readByte() 方法

readChar() 方法

readDouble() 方法

readFloat() 方法

readInt() 方法

readLong() 方法

readUnsignedByte() 方法

readUnsignedShort() 方法

readUTF() 方法

skipBytes(int maxlen) 方法

readFully(byte[] destination) 方法

readFully(byte[] destination, int offset, int maxlen) 方法

相关帖子

Java 中查找标记索引的最大数量

DoubleBuffer equals() method in Java with Examples

Java 中的别名

Java String Encoding

Why String is Immutable or Final in Java

InvocationTargetException

Java 8 和 Java 11 的区别

Java 中的 Null 对象设计模式

Blockchain Java

Java 中的 java.util.function.DoublePredicate 接口及示例

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器