Writing Data to a Binary File in Java

Shashi Preetham — Fri, 26 Mar 2021 10:19:55 +0000

Binary Files

Computers are based on the binary numbering system, which consists of just two unique numbers, 0 and 1. All operations that are possible in the decimal system (addition, subtraction, multiplication, division) are equally possible in the binary system.

A binary file is computer-readable but not human-readable. All executable programs are stored in binary files, as are most numeric data files. In contrast, text files are stored in a form (usually ASCII) that is human-readable.

Writing Data to A Binary File

Accepting the data values from the console and sending them from memory buffer to a secondary storage device. It deals with all types of primitive data viz. short, int, long, float, double, char, boolean, and String. In this system, the data are stored in terms of bytes in the secondary storage devices.
Follow the following steps while creating a binary file:

1. Create the file in output stream mode along with the stream object.

Syntax:
FileOutputStream <object> = new FileOutputStream <file name>

For example,

FileOutputStream fout = new FileOutputStream("example.dat");

The extension of the file name (.dat) signifies the type of data that is stored in the output stream mode in the hard disk.

2. Create a link between the object of the FileOutputStream with the buffer output stream.

Syntax:
DataOutputStream <object> = new DataOutputStream(FileOutputStream object);

For example:

DataOutputStream dout = new DataOutputStream(fout);

3. Accept the required data from the console in one of the two ways:

(a) Using stream reader by importing java.io.*
(b) Using Scanner class by importing java.util.*

4. Write the data in the secondary storage with the help of these commands:

To write short type data - <object>.writeShort<variable name>
To write integer type data - <object>.writeInt<variable name>
To write long type data - <object>.writeLong<variable name>
To write float type data - <object>.writeFloat<variable name>
To write double type data - <object.writeDouble<variable name>
To write character type data - <object>.writeChar<variable name>
To write string type data - <object>.writeUTF<variable name>

(UTF stands for Unicode Transformed Format string)

5. Close the data file using FileOutputStream object as:

<object>.close();

Sample Program

An Electronic Store wants to make an inventory of all types of products in a binary file "inventory.dat" to input product name, product code, quantity of product and price.
Following is a program to create a binary file to perform the above task.

import java.io.*;
public class sample {
    public static void main(String args[]) throws IOException {
        BufferedReader ob=new BufferedReader(new InputStreamReader(System.in));

        // Creating binary file
        FileOutputStream fout=new FileOutputStream("inventory.dat");
        DataOutputStream dout=new DataOutputStream(fout);

        int n, q, pr;
        String str, pc;
        System.out.println("Enter number of products:");
        n=Integer.parseInt(ob.readLine());
        for(int i=1;i<=n;i++) {
            System.out.println("Enter product name");
            str=ob.readLine();
            System.out.println("Enter product code");
            pc=ob.readLine();
            System.out.println("Enter product quantity");
            q=Integer.parseInt(ob.readLine());
            System.out.println("Enter price");
            pr=Integer.parseInt(ob.readLine());

            // Writing data values from memory to binary file
            dout.writeUTF(str);
            dout.writeUTF(pc);
            dout.writeInt(q);
            dout.writeInt(pr);
        }
        // Closing binary file object
        fout.close();
        dout.close();
        ob.close();
    }
}

Implementing Min Heap in Java

Shashi Preetham — Fri, 26 Mar 2021 09:18:30 +0000

A Min-Heap is a complete binary tree in which the value in each internal node is smaller than or equal to the values in the children of that node.

Mapping the elements of a heap into an array is trivial: if a node is stored an index n, then its left child is stored at index 2n+1 and its right child at index 2n+2.

Example

Min Heap Representation

A Min heap is typically represented as an array.
Consider an array Arr[] with root at Arr[0]. For any i^th node, i.e., Arr[i]:

Arr[(i -1) / 2] returns its parent node.
Arr[(2 * i) + 1] returns its left child node.
Arr[(2 * i) + 2] returns its right child node.

Operations on Min Heap

getMin(): It returns the root element of Min Heap. Time Complexity of this operation is O(1).
extractMin(): Removes the minimum element from MinHeap. Time Complexity of this Operation is O(Log n) as this operation needs to maintain the heap property (by calling heapify()) after removing root.
insert(): Inserting a new key takes O(Log n) time. We add a new key at the end of the tree. If new key is larger than its parent, then we don’t need to do anything. Otherwise, we need to traverse up to fix the violated heap property.

Implementation of Min Heap in Java using Priority Queues

Here’s how you can implement a min heap using PriorityQueue class in Java. By default Min Heap is implemented by this class.

import java.util.*;
public class MinHeap {
    static PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
    public static void main(String args[]) {

        // Adding elements using add()
        minHeap.add(8);
        minHeap.add(5);
        minHeap.add(13);
        minHeap.add(2);
        minHeap.add(23);
        minHeap.add(16);

        // Displaying minHeap elements
        print();

        // Find number of elements using size()
        System.out.println("Size of heap = "+minHeap.size());

        // View head using peek()
        System.out.println("Head = "+minHeap.peek());

        // Remove head and modify Heap using poll()
        minHeap.poll();
        System.out.println("Heap after removing head");
        print();

        // Remove specific element using remove()
        minHeap.remove(8);
        System.out.println("Heap after removing 8");
        print();

        // Check if an element is present using contains()
        boolean flag=minHeap.contains(15);
        System.out.println("Does heap contain element 15? " +flag);

        System.out.println("Size of heap = "+minHeap.size());
    }
    public static void print() {
        System.out.print("Min Heap : ");
        for(Integer i:minHeap)
            System.out.print(i+" ");
        System.out.println("\n");
    }
}

Output

Min Heap : 2 5 13 8 23 16 

Size of heap = 6
Head = 2
Heap after removing head
Min Heap : 5 8 13 16 23 

Heap after removing 8
Min Heap : 5 16 13 23

DEV Community: Shashi Preetham