DataOutputStream Class in Java

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

The DataOutputStream class in Java is part of the java.io package and allows an application to write primitive data types to an output stream in a machine-independent way.

This class is essential for writing primitive data types (such as int, float, double, etc.) to a stream in a way that ensures the data is interpreted correctly regardless of the platform.

It is often used in scenarios where you need to write binary data such as numbers and characters that are encoded in a specific way, ensuring portability across different machine architectures.

By providing methods to write Java's primitive data types, DataOutputStream makes it easier to handle binary I/O operations.

Creating a DataOutputStream
Writing Data with DataOutputStream
Closing the Stream
Complete Example
Conclusion

Creating a DataOutputStream

To create a DataOutputStream, you need to wrap it around another output stream, such as a FileOutputStream. This enables you to write data to a file or another output destination in a binary format.

Example

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

public class DataOutputStreamExample {
    public static void main(String[] args) {
        try {
            // Creating DataOutputStream using FileOutputStream
            FileOutputStream fos = new FileOutputStream("example.dat");
            DataOutputStream dos = new DataOutputStream(fos);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

In the example above, DataOutputStream is created using a FileOutputStream to write to a file named example.dat.

Writing Data with DataOutputStream

The DataOutputStream class provides several methods to write primitive data types to the output stream:

void writeBoolean(boolean v): Writes a boolean value.
void writeByte(int v): Writes an 8-bit byte.
void writeChar(int v): Writes a 16-bit character.
void writeDouble(double v): Writes a 64-bit double.
void writeFloat(float v): Writes a 32-bit float.
void writeInt(int v): Writes a 32-bit integer.
void writeLong(long v): Writes a 64-bit long.
void writeShort(int v): Writes a 16-bit short.
void writeUTF(String str): Writes a string in UTF-8 format.

Example

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamWriteExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("example.dat"))) {
            dos.writeInt(12345);
            dos.writeDouble(123.45);
            dos.writeBoolean(true);
            dos.writeUTF("Hello, World!");

            System.out.println("Data written to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In the example above, DataOutputStream writes an integer, a double, a boolean, and a UTF-8 encoded string to a file named example.dat.

Closing the Stream

It is important to close the DataOutputStream after completing the I/O operations to release the system resources associated with the stream. This can be done using the close() method.

Example

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamCloseExample {
    public static void main(String[] args) {
        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new FileOutputStream("example.dat"));
            dos.writeInt(12345);
            dos.writeDouble(123.45);
            dos.writeBoolean(true);
            dos.writeUTF("Hello, World!");

            System.out.println("Data written to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (dos != null) {
                    dos.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

In the example above, the DataOutputStream is closed in the finally block to ensure that it is closed even if an exception occurs.

Alternatively, you can use the try-with-resources statement, which ensures that the stream is closed automatically.

Example

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamTryWithResourcesExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("example.dat"))) {
            dos.writeInt(12345);
            dos.writeDouble(123.45);
            dos.writeBoolean(true);
            dos.writeUTF("Hello, World!");

            System.out.println("Data written to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In the example above, the try-with-resources statement is used to automatically close the DataOutputStream.

Complete Example

Here is a complete example demonstrating the creation, writing, and closing of a DataOutputStream.

DataOutputStreamExample.java

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("example.dat"))) {
            dos.writeInt(12345);
            dos.writeDouble(123.45);
            dos.writeBoolean(true);
            dos.writeUTF("Hello, World!");

            System.out.println("Data written and flushed to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In this example, a DataOutputStream is created, data is written to a file, the stream is flushed, and the stream is automatically closed using the try-with-resources statement.

Conclusion

The DataOutputStream class in Java is used for writing primitive data types to an output stream in a machine-independent way. By understanding how to create, write, and close a DataOutputStream, you can effectively handle binary I/O operations in your Java applications. Remember to always close the stream after use to ensure that system resources are properly released.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog