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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 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.
1
2
3
4
5
| 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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| //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.
1
2
3
4
5
6
7
8
9
10
11
12
| 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.
1
2
3
4
5
6
7
| 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.
1
2
3
4
5
| //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.
1
2
3
4
5
6
7
8
9
10
| 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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
| /* 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]);
}
} |
