# ObjectInputStream

The Java `ObjectInputStream` class (`java.io.ObjectInputStream`) enables you to read Java objects from an `InputStream` instead of just raw bytes. You wrap an `InputStream` in a `ObjectInputStream` and then you can read objects from it. Of course the bytes read must represent a valid, serialized Java object. Otherwise reading objects will fail.

Normally you will use the `ObjectInputStream` to read objects written (serialized) by a [Java `ObjectOutputStream`](https://jenkov.com/tutorials/java-io/objectoutputstream.html) . You will see an example of that later.

### ObjectInputStream Example

Here is a Java `ObjectInputStream` example:

```
ObjectInputStream objectInputStream =
    new ObjectInputStream(new FileInputStream("object.data"));

MyClass object = (MyClass) objectInputStream.readObject();
//etc.

objectInputStream.close();
```

For this `ObjectInputStream` example to work the object you read must be an instance of `MyClass`, and must have been serialized into the file "object.data" via an `ObjectOutputStream`.

Before you can serialize and de-serialize objects the class of the object must implement `java.io.Serializable`. For more info, see [Java Serializable](https://jenkov.com/tutorials/java-io/serializable.html).

### Using an ObjectInputStream With an ObjectOutputStream

I promised earlier to show you an example of using the Java `ObjectInputStream` with the `ObjectOutputStream`. Here is that example:

```
import java.io.*;

public class ObjectInputStreamExample {

    public static class Person implements Serializable {
        public String name = null;
        public int    age  =   0;
    }


    public static void main(String[] args) throws IOException, ClassNotFoundException {

        ObjectOutputStream objectOutputStream =
            new ObjectOutputStream(new FileOutputStream("data/person.bin"));

        Person person = new Person();
        person.name = "Jakob Jenkov";
        person.age  = 40;

        objectOutputStream.writeObject(person);
        objectOutputStream.close();


        ObjectInputStream objectInputStream =
            new ObjectInputStream(new FileInputStream("data/person.bin"));

        Person personRead = (Person) objectInputStream.readObject();

        objectInputStream.close();

        System.out.println(personRead.name);
        System.out.println(personRead.age);
    }
}
```

This example first creates an `ObjectOutputStream` connected to a `FileOutputStream`. Then it creates a `Person` object and writes it to the `ObjectOutputStream`, and then closes the `ObjectOutputStream`.

Then the example creates an `ObjectInputStream` connected to the same file the `ObjectOutputStream` was connected to. The example then reads in an object from the `ObjectInputStream` and casts it to a `Person` object. After that the `ObjectInputStream` is also closed, and the values read into the `Person` object are printed to `System.out`.

The output printed from running this example should be:

```
Jakob Jenkov
40
```