JAVA EE: Primitive Types

Showing posts with label Primitive Types. Show all posts

Wednesday, 12 October 2016

Java Tutorial : Java IO (Java Serialization - How to serialize primitive values)

🚀 Enjoying Java Tutorials?

Subscribe to Ram N Java for clean, beginner-friendly core Java tutorials and interview prep!

Introduction

While Java serialization is widely recognized for saving objects, you frequently need to write and restore raw primitive values—such as int, boolean, double, or long—directly to an output stream. In this guide, we break down how Java IO handles primitive serialization using ObjectOutputStream and ObjectInputStream.

Writing and Reading Primitive Data

ObjectOutputStream implements the DataOutput interface, providing dedicated methods to write primitive values directly into the byte stream without wrapping them in complex custom objects.

Common Methods for Writing Primitives

writeInt(int val): Writes a 32-bit integer.
writeDouble(double val): Writes a 64-bit double-precision floating point number.
writeBoolean(boolean val): Writes a boolean value as a 1-byte value.
writeUTF(String str): Writes a string using modified UTF-8 encoding.

Restoring Primitives with ObjectInputStream

To read the primitives back, ObjectInputStream implements DataInput and provides matching methods:

readInt()
readDouble()
readBoolean()
readUTF()

Key Rules to Remember

Order Matters: Primitive values must be read back in the exact same sequence and type order in which they were written. Reading an int when a double was written will result in corrupted data or stream errors.

Mixing Objects and Primitives: You can seamlessly combine calls to writeObject() and primitive write methods like writeInt() on the same stream, provided you mirror the operations during deserialization.

Related Tutorials from Ram N Java

Click here to watch in Youtube :
https://www.youtube.com/watch?v=hupxVOkTnhM&list=UUhwKlOVR041tngjerWxVccw

Serialization.java

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

public class Serialization
{

    public static void main(String[] args) throws FileNotFoundException,
            IOException, ClassNotFoundException
    {
        Serialization serialization = new Serialization();
        serialization.writePrimitiveValues();
    }

    private void writePrimitiveValues() throws FileNotFoundException,
            IOException
    {
        FileOutputStream fileOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try
        {
            fileOutputStream = new FileOutputStream("myfile.txt");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);

            objectOutputStream.writeInt(10);
            objectOutputStream.writeDouble(50.55);
            objectOutputStream.writeBoolean(true);
            
            System.out
                    .println("Successfully written primitive values to the file.\n");
        }
        finally
        {

            if (objectOutputStream != null)
            {
                /*
                 * Closing a ObjectOutputStream will also
                 * close the OutputStream instance to which
                 * the ObjectOutputStream is writing.
                 */
                objectOutputStream.close();
            }
        }

    }

}

Output
Successfully written primitive values to the file.

myfile.txt

DeSerialization.java

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeSerialization
{

    public static void main(String[] args) throws FileNotFoundException,
            IOException, ClassNotFoundException
    {
        DeSerialization deSerialization = new DeSerialization();
        deSerialization.readPrimitiveValues();
    }

    private void readPrimitiveValues() throws IOException,
            FileNotFoundException, ClassNotFoundException
    {
        FileInputStream fileInputStream = null;
        ObjectInputStream objectInputStream = null;

        try
        {
            fileInputStream = new FileInputStream("myfile.txt");
            objectInputStream = new ObjectInputStream(fileInputStream);

            System.out
                    .println("Successfully read primitive values from the file.\n");

            int intValue = objectInputStream.readInt();
            double doubleValue = objectInputStream.readDouble();
            boolean booleanValue = objectInputStream.readBoolean();

            System.out.println("intValue = " + intValue);
            System.out.println("doubleValue = " + doubleValue);
            System.out.println("booleanValue = " + booleanValue);

        }
        finally
        {

            if (objectInputStream != null)
            {
                /*
                 * Closing a ObjectInputStream will also
                 * close the InputStream instance from which
                 * the ObjectInputStream is reading.
                 */
                objectInputStream.close();
            }
        }

    }

}

Output

Successfully read primitive values from the file.

intValue = 10
doubleValue = 50.55
booleanValue = true

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/JavaIODemo_Serialization_primitive_App.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/JavaIODemo_Serialization_primitive_App

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/9f822df4c81f286daa095d86846058f3a9c16303/BasicJava/JavaIODemo_Serialization_primitive_App/?at=master

See also:

All JavaEE Viedos Playlist

All JavaEE Viedos

All JAVA EE Links

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial