write • Code With Design

Writing and reading objects and arrays to a binary file with java

by: Caleb Jonasson - April 7th, 2010 Filed under: Java 1 Comment

This article requires that you have read the following java tutorials or you feel comfortable writing and reading variables to a binary file.

Advantage of writing files in binary with java

Reading information from a binary file with java

Writing information to a binary file with java

The first thing that is needed in this tutorial is an object that we are going to save into binary. This object is going to be a simple object with one instance variable, two constructors, one of which is default and a get name method.

import java.io.Serializable;
public class Person implements Serializable{
    private String name;
 
    public Person(){
        name = "no name";
    }
    public Person(String x){
        name = x;
    }
    public String getName(){
        return name;
    }
}

You may notice that at the top of our new object we have a line that says “import java.io.Serializable” This line imports a class that we can use. It is required when we want to turn an object into binary and save it to a file. There is also a line that implements Serializable. This line is needed so the class can use the methods within the class Serializable.

The next piece of code will be added outside of the main method. It is added because we will need to use the file input and output streams along with the object input and output streams. We will also be using an IOException. If you would like to use other exception handling classes you can certainly feel free too. I would advise using the file not found and end of file exception.

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

This next bit of code is going to save what we want for a filename inside of a string variable. After that we will be creating two person objects and two arrays, one being a string type and the other an integer type. The next line of code will create a null output stream then create the output stream while testing it for any errors.

//the filename to create.
        String fileName = "file.dat";
 
        //Person Objects
        Person p1 = new Person("Bob");
        Person p2 = new Person("Paul");
 
        //Array to write
        String[] helloThere = new String[]{"dog","cat","hamburger"};
        int[] thereHello = new int[]{1,2,3,4,5,6,7,8,9};
 
        //creating the space in memory for the file
        ObjectOutputStream  outputStream = null;
 
        try{
            outputStream = new ObjectOutputStream(new FileOutputStream(fileName));
        }catch(IOException e){
            System.out.println("Could not open the file." + e);
            System.exit(0);
        }

Writing the objects to a binary file is done in a similar way to writing everything else. Since an array is actually an object it uses the same method as the object person. To write these two kinds of objects we will need to use the try catch in order to handle any errors then inside of that write objects using the outputstream.

try{
            outputStream.writeObject(p1);
            outputStream.writeObject(p2);
            outputStream.writeObject(helloThere);
            outputStream.writeObject(thereHello);
 
            outputStream.close();
 
        }catch(IOException e){
            System.out.println("Writing error: " + e);
            System.exit(0);
        }

Now that we are done writing the objects to the binary file we will need to read the information back into new objects.

We are going to create a new input stream in the same way that we made the output stream. It will first be of type null and then we will truly create it inside of the try catch blocks.

ObjectInputStream inputStream = null;
        try{
            inputStream = new ObjectInputStream(new FileInputStream(fileName));
        }catch(IOException e){
            System.out.println("There was a problem opening the file: " + e);
            System.exit(0);
        }

Since we are going to pull the information out of the file and reload them as objects we will need to create new objects in memory to show that we have successfully read the file.

//Create new blank objects to store the data in.
        Person newp1 = null;
        Person newp2 = null;
        String[] test = null;
        int[] test2 = null;

In order to read the information we will rely on our trusted try and catch blocks to let us test that everything is going as planned. Inside of the try catch blocks there is going to be the code required to load the objects read from memory into the new objects that we created in the code above.

You will also notice that when we saved the object information to a new object we specified what kind of object it was. This casts the information and sets it up as said object so it can once again use the methods that come along with that object type.

try{
            newp1 = (Person)inputStream.readObject();
            newp2 = (Person)inputStream.readObject();
            test = (String[])inputStream.readObject();
            test2 = (int[])inputStream.readObject();
            inputStream.close();
        }catch(Exception e){
            System.out.println("There was an issue reading from the file: " + e);
            System.exit(0);
        }

The last thing required is for us to do is test a person and an array. We will do this as follows.

1 2	System.out.println("newp1\'s name is " + newp1.getName()); System.out.println(test2[0]);

If everything goes according to plan then we will have no errors. If you do have an error then please refer to the last bit of code to see if you did anything wrong.

/* Code with Design
 *
 * Created By: Caleb Jonasson
 *
 * Desc: This class file is used to create a binary file,
 * write values to the file and check for errors along the way.
 */
 
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
 
public class writebin {
 
    public static void main(String[] args) {
        //the filename to create.
        String fileName = "file.dat";
 
        //Person Objects
        Person p1 = new Person("Bob");
        Person p2 = new Person("Paul");
 
        //Array to write
        String[] helloThere = new String[]{"dog","cat","hamburger"};
        int[] thereHello = new int[]{1,2,3,4,5,6,7,8,9};
 
        //creating the space in memory for the file
        ObjectOutputStream  outputStream = null;
 
        try{
            outputStream = new ObjectOutputStream(new FileOutputStream(fileName));
        }catch(IOException e){
            System.out.println("Could not open the file." + e);
            System.exit(0);
        }
 
 
 
        try{
            outputStream.writeObject(p1);
            outputStream.writeObject(p2);
            outputStream.writeObject(helloThere);
            outputStream.writeObject(thereHello);
 
            outputStream.close();
 
        }catch(IOException e){
            System.out.println("Writing error: " + e);
            System.exit(0);
        }
        System.out.println("Records have been written to the file.");
 
 
        /*Reading the objects from memory.*/
 
        ObjectInputStream inputStream = null;
        try{
            inputStream = new ObjectInputStream(new FileInputStream(fileName));
        }catch(IOException e){
            System.out.println("There was a problem opening the file: " + e);
            System.exit(0);
        }
 
        //Create new blank objects to store the data in.
        Person newp1 = null;
        Person newp2 = null;
        String[] test = null;
        int[] test2 = null;
 
        try{
            newp1 = (Person)inputStream.readObject();
            newp2 = (Person)inputStream.readObject();
            test = (String[])inputStream.readObject();
            test2 = (int[])inputStream.readObject();
            inputStream.close();
        }catch(Exception e){
            System.out.println("There was an issue reading from the file: " + e);
            System.exit(0);
        }
        System.out.println("Reading of the file: " + fileName + " has been completed.");
 
        //Now we test to make sure that it worked correctly.
        System.out.println("newp1\'s name is " + newp1.getName());
        System.out.println(test2[0]);
 
    }
 
}

Tags: array, binary, Java, object, read, write

Writing information to a binary file in java

by: Caleb Jonasson - March 30th, 2010 Filed under: Java 1 Comment

In this tutorial I will be showing you how to import the required IO classes, check for errors using a try catch and write to a binary file. In order to do this tutorial a basic knowledge of Java, methods and variables is required.

Get the files used in this tutorial.

The first thing we need to do is import our classes. The classes we will import are going to be the following: “ObjectOutputStream”, “FileOutputStream” and the IOException.

1
2
3

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

The next thing that is required is to create the object “ObjectOutputStream.” We will do this by using the classes we imported at the start of this tutorial. We will also be placing this into a try catch statement to see if we are properly opening the file.

String fileName = "file.dat";
        try{
            outputStream = new ObjectOutputStream(new FileOutputStream(fileName));
        }catch(IOException e){
            System.out.println("Could not open the file." + e);
            System.exit(0);
        }

Take note that we are getting the file name from the a string variable and using it in our new file stream.

Since we now have our file created and classes imported the next thing required is for us to create all of the variables we will be using in this example. Since I will be using all of the primitive variable types there will be a fair sized list you will need to type out.

byte foo = 1;
        short bar = 5;
        int baz = 543;
        long qurk = 123923892;
 
        float flt = 1;
        double dbl = 1.2323;
 
        char chr = 'a';
        String str = "hello";
 
        boolean bool = false;

The next step is to write all of the variables to the file through the output stream. Once again this will be done using try catch block but you shouldn’t have a problem if you follow along correctly.

try{
            //integet based
            outputStream.writeByte(foo);
            outputStream.writeShort(bar);
            outputStream.writeInt(baz);
            outputStream.writeLong(qurk);
 
            //decimal based
            outputStream.writeFloat(flt);
            outputStream.writeDouble(dbl);
 
            //alpha based
            outputStream.writeChar(chr);
            outputStream.writeUTF(str);
 
            //true false based
            outputStream.writeBoolean(bool);
 
            outputStream.close();
 
        }catch(IOException e){
            System.out.println("Writing error: " + e);
            System.exit(0);
        }

The final piece of the code will close the output stream and tell us that we have successfully written to a file.

1	System.out.println("Records have been written to the file.");

The file with everything in it is as follows:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class writebin {
    public static void main(String[] args) {
        String fileName = "file.dat";
 
        ObjectOutputStream  outputStream = null;
 
        try{
            outputStream = new ObjectOutputStream(new FileOutputStream(fileName));
        }catch(IOException e){
            System.out.println("Could not open the file." + e);
            System.exit(0);
        }
 
        byte foo = 1;
        short bar = 5;
        int baz = 543;
        long qurk = 123923892;
 
        float flt = 1;
        double dbl = 1.2323;
 
        char chr = 'a';
        String str = "hello";
 
        boolean bool = false;
 
        try{
            //integet based
            outputStream.writeByte(foo);
            outputStream.writeShort(bar);
            outputStream.writeInt(baz);
            outputStream.writeLong(qurk);
 
            //decimal based
            outputStream.writeFloat(flt);
            outputStream.writeDouble(dbl);
 
            //alpha based
            outputStream.writeChar(chr);
            outputStream.writeUTF(str);
 
            //true false based
            outputStream.writeBoolean(bool);
 
            outputStream.close();
 
        }catch(IOException e){
            System.out.println("Writing error: " + e);
            System.exit(0);
        }
        System.out.println("Records have been written to the file.");
    }
 
}

Tags: binary, file, IO, Java, ObjectOutputStream, outputStream, stream, write

Code With Design

Writing and reading objects and arrays to a binary file with java

Writing information to a binary file in java

Find

Powered By

Comments

Dream In Code

Categories

The Past

Blogs I read

Meta

Areas

Thanks

Comments

Pages