Java StreamCorruptedException Class
Last modified: April 16, 2025
The java.io.StreamCorruptedException is thrown when the stream header
is invalid or when control information read from the stream violates consistency
checks. It indicates corruption in object serialization streams.
This exception typically occurs during deserialization when reading objects from
an ObjectInputStream. It signals that the stream data is corrupted
or was written incorrectly. The exception extends ObjectStreamException.
StreamCorruptedException Class Overview
StreamCorruptedException is part of Java's object serialization
mechanism. It contains constructors to create exceptions with or without detail
messages. The class inherits standard exception functionality from its hierarchy.
public class StreamCorruptedException extends ObjectStreamException {
public StreamCorruptedException();
public StreamCorruptedException(String reason);
}
The code above shows the simple structure of StreamCorruptedException.
The parameterless constructor creates an exception without a message. The second
constructor allows specifying a detailed error message explaining the corruption.
Basic Stream Corruption Example
This example demonstrates a simple case where StreamCorruptedException
occurs. We'll intentionally corrupt a serialized stream by modifying its header.
The exception helps detect invalid serialization streams early.
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
// Create a byte array output stream
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
// Write a simple string
oos.writeObject("Hello, World!");
oos.close();
// Get the bytes and corrupt the stream header
byte[] data = baos.toByteArray();
data[0] = 0; // Corrupt the magic number
// Try to read the corrupted stream
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
// This will throw StreamCorruptedException
String s = (String) ois.readObject();
ois.close();
} catch (StreamCorruptedException e) {
System.err.println("Stream corrupted: " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
In this example, we first serialize a string to a byte array. Then we deliberately
corrupt the stream header by changing the first byte. When attempting to
deserialize, the invalid header triggers StreamCorruptedException.
Mismatched Object Stream Version
This example shows how version mismatches between serialization and deserialization
can cause StreamCorruptedException. Different JVMs or serialization
versions may produce incompatible streams.
import java.io.*;
public class Main {
static class Data implements Serializable {
private static final long serialVersionUID = 1L;
String value;
Data(String value) {
this.value = value;
}
}
public static void main(String[] args) {
try {
// Serialize with one version UID
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(new Data("Test"));
oos.close();
// Get bytes and modify version UID in the stream
byte[] data = baos.toByteArray();
// Simulate version change by altering serialVersionUID bytes
data[20] = (byte) ~data[20];
// Attempt deserialization
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
// This throws StreamCorruptedException
Data d = (Data) ois.readObject();
ois.close();
} catch (StreamCorruptedException e) {
System.err.println("Version mismatch detected: " + e);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Here we simulate a version mismatch by altering the serialVersionUID
in the stream. The deserialization fails with StreamCorruptedException
because the modified version doesn't match the class definition. This protects
against incompatible serialized data.
Invalid Stream Header Format
This example demonstrates how an invalid stream header format causes
StreamCorruptedException. The header contains magic numbers and
version info that must match expected values.
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
// Create a valid serialized stream
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject("Valid data");
oos.close();
// Prepend invalid header bytes
byte[] validData = baos.toByteArray();
byte[] invalidData = new byte[validData.length + 4];
System.arraycopy(validData, 0, invalidData, 4, validData.length);
// Try to deserialize
ByteArrayInputStream bais = new ByteArrayInputStream(invalidData);
ObjectInputStream ois = new ObjectInputStream(bais);
// Throws StreamCorruptedException due to invalid header
String s = (String) ois.readObject();
ois.close();
} catch (StreamCorruptedException e) {
System.err.println("Invalid stream header: " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
We create a valid serialized stream then prepend extra bytes to corrupt the
header format. The ObjectInputStream detects the invalid header
immediately and throws StreamCorruptedException. This prevents
processing of malformed streams.
Truncated Stream Detection
This example shows how StreamCorruptedException helps detect
truncated streams. Incomplete serialization data causes consistency check
failures during deserialization.
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
// Serialize multiple objects
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject("First object");
oos.writeObject("Second object");
oos.close();
// Truncate the stream data
byte[] fullData = baos.toByteArray();
byte[] truncatedData = new byte[fullData.length / 2];
System.arraycopy(fullData, 0, truncatedData, 0, truncatedData.length);
// Attempt deserialization
ByteArrayInputStream bais = new ByteArrayInputStream(truncatedData);
ObjectInputStream ois = new ObjectInputStream(bais);
// First object reads fine
String first = (String) ois.readObject();
System.out.println("Read: " + first);
// Second object throws StreamCorruptedException
String second = (String) ois.readObject();
ois.close();
} catch (StreamCorruptedException e) {
System.err.println("Truncated stream detected: " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
We serialize two objects then truncate the byte array. The first object
deserializes successfully, but attempting to read the second throws
StreamCorruptedException. The exception indicates the stream ended
unexpectedly during deserialization.
Custom Serialization Corruption
This example demonstrates how invalid custom serialization can cause
StreamCorruptedException. The writeObject and
readObject methods must maintain consistency.
import java.io.*;
public class Main {
static class CustomData implements Serializable {
private String value;
CustomData(String value) {
this.value = value;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(123); // Write extra data
}
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
in.defaultReadObject();
// Forget to read the extra data
}
}
public static void main(String[] args) {
try {
// Serialize
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(new CustomData("Test"));
oos.close();
// Deserialize
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
// Throws StreamCorruptedException due to unread data
CustomData cd = (CustomData) ois.readObject();
ois.close();
} catch (StreamCorruptedException e) {
System.err.println("Custom serialization error: " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
The CustomData class writes extra data in writeObject
but doesn't read it in readObject. This inconsistency causes
StreamCorruptedException during deserialization. The exception
helps catch serialization/deserialization mismatches.
Network Stream Corruption
This example simulates network stream corruption that might cause
StreamCorruptedException. Network issues can corrupt serialized
data during transmission.
import java.io.*;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
try {
// Simulate network transmission with potential corruption
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(Arrays.asList("A", "B", "C"));
oos.close();
// Simulate network corruption by flipping some bits
byte[] transmitted = baos.toByteArray();
for (int i = 10; i < 20; i++) {
transmitted[i] = (byte) ~transmitted[i];
}
// Attempt deserialization
ByteArrayInputStream bais = new ByteArrayInputStream(transmitted);
ObjectInputStream ois = new ObjectInputStream(bais);
// Throws StreamCorruptedException due to corrupted data
java.util.List<?> list = (java.util.List<?>) ois.readObject();
ois.close();
System.out.println("Read list: " + list);
} catch (StreamCorruptedException e) {
System.err.println("Network corruption detected: " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
We simulate network corruption by flipping bits in the serialized data. The
ObjectInputStream detects the corrupted data and throws
StreamCorruptedException. In real applications, checksums or
retransmission would handle such errors.
Source
Java StreamCorruptedException Class Documentation
In this article, we've explored various scenarios that can cause
StreamCorruptedException in Java. Understanding these cases helps
develop robust serialization code and proper error handling.
Author
List all Java tutorials.