Data Structures in Java – A Complete Explanation

While building a house, you stack one brick over the other to give it a precise form and structure. Similarly, the Data Structures in the Java programming language follow a similar pattern. They work as building blocks in Java to provide data with a specific form and structure and make the program run efficiently on computers.  

Now, it's no doubt that Java has become the third most used programming language worldwide, after Python and C, according to TIOBE Index. With such a vast adoption rate, budding programmers must be familiar with the key features of Java, which also includes Data Structures.  

So, familiarity with Data Structures is necessary for all programmers in order to understand Java in detail. But you ask how? Look no further! In this blog, you will learn about Data Structures in Java, with syntax and examples. 

Table of Contents 

1) Data Structures in Java explained 

2) Some functions of Java Data Structure 

3) Java Data Structures and  their types 

     a) Linear type 

     b) Non-linear type 

4) What are the advantages of Java Data Structure? 

6) Conclusion 

Data Structures in Java explained 

Before beginning to understand what are Data Structures in Java, it is essential to learn about the basics of Data Structures present in various programming languages.  

Data Structures are the way of storing, organising, and managing data in any programming language. The data is arranged in such a manner that computers, software, applications and other machines can be accessed and updated efficiently.  

 In Java, the Data Structure is a set of algorithms stored in data memory, and the data is further organised using different types of Data Structures to run computers efficiently. 

 

 

Functions of Data Structures in Java

You can perform a number of  operations to arrange the data efficiently. Here is the list of some operations performed on the Java Data Structure: 

1) Sort: The sorting function allows filtering out elements of a Data Structure in ascending and descending order. 

2) Search: It helps look for a specific element from a stack of elements in a Data Structure. 

3) Add: Adds or inserts a new element to a stack of elements. 

4) Delete: It is possible to remove the elements from a Data Structure. 

5) Update: Replacing one element with another element within a Data Structure can be done through updating operation. 

Java Data Structures and their types 

As you have read, Data Structures are fundamental to every programming language. So, let’s look at what Java has in its basket for us. Essentially, there are two types of Data Structures in this programming language. These are as follows: 

Linear Data Structures

In the Linear type of Data Structures, the elements are organised in a sequential, linear pattern. In simple terms, every element has its adjacent element, with the previous and next elements in line.  

Thus, only a single level of elements is involved to traverse all of them in one go. As a result, the Programmer can easily implement a linear Data Structure over the computer memory. There are many other linear Data Structures; let’s have a look at them in detail: 

1) Array: An Array is a linear Data Structure that stores a bundle of items in adjacent memory locations with each element of 4 bytes. The elements or items stored here are similar and can be randomly and directly accessed using their index numbers. Thus, an Array becomes the simplest Data Structure. Here is an example of how we can declare an Array in Java:
 

public class PrintArray
{
public static void main(String[] args)
{
// declare and initialize an array of integers int[] numbers = {1, 2, 3, 4, 5};
// print out the elements in the array
for (int i = 0; i < numbers.length; i++)
{
System.out.println(numbers[i]);
}
}
}
 

Its output is: 

int[] numbers = {1, 2, 3, 4, 5}; 

2) Linked List: Unlike Array, the Linked List Data Structure stores each element in a separate data part and address part. Each element is known as a Node linked using pointers and addresses. But it can also hold multiple elements of the same data type and has no fixed size. Thus, it is a dynamic Data Structure. Four different types of Linked Lists are: 

a) Singly Linked List 

b) Doubly Linked List 

c) Circular Linked List 

d) Circular Doubly Linked List 

Here is an example of how you can declare a Linked List in Java programming language: 
 

import java.util.LinkedList;
public class LinkedListExample
{
public static void main(String[] args)
{
// Creating a linked list
LinkedList list = new LinkedList();
// Adding elements to the linked list
list.add("A");
list.add("B");
list.add("C");
// Printing the elements in the linked list
System.out.println("Elements in the linked list:");
for (String element : list)
{
System.out.println(element);
}
}
}

Its output will be: 

Elements in the linked list: 
A 
B 
C 

3) Stack: The Stack in Java follows a LIFO (Last-In-First-Out) pattern. It means that whenever an element is added to the Stack, it is removed only from its top. The last added element is first in the line to be removed. Thus, it only has one end to insert and delete the data.
 

import java.util.*;
public class StackExample
{
public static void main(String[] args)
{
Stack stack = new Stack<>();
// Pushing elements into the stack
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
// Printing elements in the stack
System.out.println("Elements in the stack: ");
for(int i = stack.size() - 1; i >= 0; i--)
{
System.out.println(stack.get(i));
}
}
}
 

Its output is as follows: 

Elements in the stack: 

5 

4 

3 

2 

1 

4) Queue: The Queue Data Structure is the opposite of Stack, which works on a FIFO (First-In-First-Out) behaviour. This implies that the elements are added from the end of the queue (enqueued) and removed from the other (dequeue). The first element stored in the queue will be deleted at last and becomes the front of the queue. At the same time, the most recently added element will be removed first. 
 

import java.util.*;
public class QueueExample
{
public static void main(String[] args)
{
Queue queue = new LinkedList<>();
// Adding elements to the queue
queue.add(1);
queue.add(2);
queue.add(3);
queue.add(4);
queue.add(5);
// Printing elements in the queue
System.out.println("Elements in the queue: ");
for(Integer i : queue)
{
System.out.println(i);
}
}
}

 

The output is: 

Elements in the queue: 

1 

2 

3 

4 

5 

Non-Linear type Data Structures

Unlike Linear Data Structures, Non-Linear Data Structures do not follow any sequence. The data stored randomly in the memory may be arranged in the form of maps, trees or graphs. As a result, elements are not stored in a single level, and the Programmer cannot run all the elements in a single run.  

Here, the data is not stored in adjacent memory locations; rather, the elements are combined in such a format that it is easy to hold and organise the data. Thus, eliminating any kind of memory wastage. There are various formats to store data elements in a Non-Linear Data Structure, and these are as follows: 

1) Graph: The Graph Data Structure stores data elements connected to each other. It forms a network of Vertices (V) and Edges (E) where a set of Edges connect Vertices to build a Graph.
 

The Graphs may be directed or undirected. While in a directed Graph, Edges make up an ordered pair with a specified path from vertex A to vertex B. Here, Node A becomes the initial node and node B becomes the terminal node. On the other hand, in an undirected Graph, the edges do not follow a set pattern. For instance, if an Edge exists between vertex A and vertex B, Vertices can be expanded from B to A and vice-versa. Here's an example of declaring a Graph in Java:
 

import java.util.*;
class Graph
{
private int V;
private LinkedList[] adj;
public Graph(int v)
{
V = v; adj = new LinkedList[v];
for (int i = 0; i < v; i++)
{
adj[i] = new LinkedList();
}
}
public void addEdge(int v, int w)
{
adj[v].add(w);
adj[w].add(v);
}
public void printGraph()
{
for (int i = 0; i < V; i++)
{
System.out.print("Vertex " + i + ": ");
for (int j = 0; j < adj[i].size(); j++)
{
System.out.print(adj[i].get(j) + " ");
}
System.out.println();
}
}
}
public class GraphExample
{
public static void main(String[] args)
{
Graph graph = new Graph(5);
graph.addEdge(0, 1);
graph.addEdge(0, 4);
graph.addEdge(1, 2);
graph.addEdge(1, 3);
graph.addEdge(1, 4);
graph.addEdge(2, 3);
graph.addEdge(3, 4);
System.out.println("Elements in the graph: ");
graph.printGraph();
}
}

 

Its output will be as follows: 

Elements in the graph: 

Vertex 0: 1 4  

Vertex 1: 0 2 3 4  

Vertex 2: 1 3  

Vertex 3: 1 2 4  

Vertex 4: 0 1 3 

Learn everything about the Java beans, controller helpers and reorganised controllers with our Web Development Using Java Training course now! 

2) Binary Tree: A Binary Tree is one of the Tree Data Structures where the tree branches contain two child nodes for each node. These child nodes are called the left child and the right side. The data represented here represents the relationship between nodes. The basic tasks that Binary Tree can perform are insertion, deletion, searching of elements, and traversing the Tree. It can also find the Tree's height, the node's level and the entire Tree's size. Similar to the real-life tree, the Tree Data Structure also has a root, but at its top. In the case of an empty tree, the value of the root becomes null. Each node in the tree has the following: 

a) Data 

b) Pointer to the left child 

c) Pointer to the right child 

The Binary Tree can be declared in the following manner: 
 

class Node
{
int value;
Node left, right;
public Node(int item)
{
value = item;
left = right = null;
}
}
class BinaryTree
{
Node root;
public BinaryTree()
{
root = null;
}
// A function to print the elements of a binary tree in-order
public void printInOrder(Node node)
{
if(node == null)
return;
printInOrder(node.left);
System.out.print(node.value + " ");
printInOrder(node.right);
}
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
System.out.println("Elements in the binary tree (in-order): ");
tree.printInOrder(tree.root);
}
}

 

The output will be: 

Elements in the binary tree (in-order): 

4 2 5 1 3 



 

3) Binary Search Tree: This is another Tree Data Structure with an advanced algorithm to examine the nodes, branches and much more. Essentially, the data is presented in a hierarchical pattern. It means nodes smaller than the root will fall in the left subtree, while nodes larger than the root will fall in the right subtree. Further, there are no duplicate nodes in a Binary Search Tree; therefore, adding, removing and sorting the elements can be easily done. Following is how you can declare a Binary Search Tree: 
 

class TreeNode
{
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x;
}
}
public class BinarySearchTreeExample
{
public static void main(String[] args)
{
// Creating a binary search tree
TreeNode root = new TreeNode(5);
root.left = new TreeNode(3);
root.right = new TreeNode(7);
root.left.left = new TreeNode(2);
root.left.right = new TreeNode(4);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(8);
// Printing the elements in the binary search tree
System.out.println("Elements in the binary search tree:");
printTree(root);
}
public static void printTree(TreeNode node)
{
if (node != null)
{
printTree(node.left);
System.out.println(node.val);
printTree(node.right);
}
}
}

 

The output is: 

Elements in the binary search tree: 

2 

3 

4 

5 

6 

7 

8 
 

4) Heap: It is a special Tree-based Data Structure that is completely a Binary Tree. In simple terms, all the levels of a Tree, except the last or the deepest one, are filled. But, if the last level of the tree remains incomplete, the nodes of that level are filled from left to right.  Here, the value of the root node is either less than or equal to the value of the child nodes. Therefore, it consists of two types of Data Structures, these are: 

a) Min-Heap – The key present in the root node must be greater than or equal to its parent value. 

b) Max-Heap – The root node's key must be less than or equal to its parent value. 

The code to declare a Heap is as follows: 

import java.util.PriorityQueue;
public class PrintHeap
{
public static void main(String[] args)
{
// declare and initialize a heap of integers
PriorityQueue heap = new PriorityQueue();
heap.add(3);
heap.add(1);
heap.add(4);
heap.add(1);
heap.add(5);
// print out the elements in the heap
while (!heap.isEmpty())
{
System.out.println(heap.poll());
}
}
}
The output will be as follows:
while (!heap.isEmpty())
{
System.out.println(heap.poll());
}

 

Learn to develop efficient and reliable software using Java program language, register now for our Java Programming And Software Engineering Fundamentals Training course now! 

What are the advantages of Java Data Structure? 

Java Data Structure offers many advantages to Programmers in many unimaginable ways. The Programmers can: 

1) Organise data into the computer’s memory 

2) Represent information in databases 

3) Implement algorithms into search engines and word processors to search and manipulate data, respectively 

4) Develop software to display graphics 

There is much more to Data Structures because of their advantageous qualities. But what are these? Let's find out: 

1) Highly efficient: In Java, the Data Structures help in storing and organising data that helps in adding, replacing, deleting and retrieving data. 

2) Reusable: The codes in Data Structures can be used repetitively to develop various algorithms and programs. 

3) Provides abstraction: Programmers not only focus on storing and manipulating the data. Rather, they can determine the logical structure of the data and the operations that can be performed on Data Structures through abstraction. 

4) Algorithm optimisation: Programmers need access to build specialised algorithms. In Java, the Data Structures provide them the freedom to access and manipulate data so that algorithms can function smoothly. 

5) High-speed memory: There is a large amount of data to be handled skilfully in Data Structure. Java Data Structure allocates and deallocates the memory vigorously to ease this task.

Conclusion 

You must know till now that Data Structures in Java builds the fundamental of this programming language. We hope you learned that it gives Java the efficiency and power to easily organise data in the form of arrays, heaps, stacks, trees and many more. 

Begin your journey to learn all essential concepts of advanced Java; register for our Introduction To Java EE Training Course now!