Top 10 Data Structures Every Java Developer Should Know (With Real-Life Examples)
Data Structures are the basic building blocks for writing efficient and scalable code. So, as a Java Developer or as a Developer, it’s important to understand which data structure to use and when to use it, and why to use data structures.
So In this post, we’ll cover the top 10 data structures every Java developer should know, with real-life examples, Java code snippets, and when to use each. Let’s dive in!
1. Array Data Structure
An array is the most basic data structure that stores elements of the same type in contiguous memory locations. Each memory location has an index, and an array index in Java starts with ‘0’.
An array index is used to access a single element from an array or to assign a value. Let’s understand it with an example.
In the above example, arrayOfFruits[0] will access banana from the arrayOfFruits, and the second statement, arrayOfFruits[2] = “Apple”, will update the array at index 2. It will update the value from orange to apple as shown in the example above.
Real-Life Use Case
Imagine you are developing weather app where you want to store daily temperatures in a week.
public class HelloWorld {
public static void main(String[] args) {
int temps = new int[7];
temps[0] = 22;
temps[1] = 30;
temps[2] = 28;
}
}
Output:
Note: Use arrays when the number of elements is known and fixed.
2. Array-List Data Structure
An ArrayList is a dynamic version of an array. In Array-List you can add, remove, or access elements using the Array-List methods.
Real-Life Use Case
Array List is useful when you are dealing with dynamic data like a shopping cart in an e-commerce app.
import java.util.ArrayList;
public class ShoppingCart {
public static void main(String[] args) {
ArrayList<String> cart = new ArrayList<>();
cart.add("Shoes");
cart.add("Shirt");
cart.add("Eype Glasses");
cart.remove("Shirt");
cart.add("Laptopp");
System.out.println(cart);
}
}
Output:
[Shoes, Eype Glasses, Laptopp]
Note: Use Array-List when you need a dynamic list with fast random access.
3. LinkedList Data Structure
A LinkedList stores elements as nodes connected by pointers.
Let’s deep dive into it using a real-life analogy. A train is the best example of a linked list, where each compartment is connected to its next compartment as shown below.
Same as in a linked list, each node is connected to its next node using a pointer.
Types of Linked-List
- Singly Linked List
- Doubly Linked List
- Circular Linked List
Singly Linked List
In a singly Linked List, each node has data and a pointer to the next node.
Doubly Linked-List
We add a pointer to the previous node in a doubly-linked list so we can go in either direction, forward or backward.
Circular Linked-List
In a Circular Linked-List the last element is connected to the first element.
Real-Life Use Case
Linked List is used when frequent insertion and deletion are needed. Like in a music playlist, where users add and delete music frequently.
import java.util.LinkedList;
LinkedList<String> playlist = new LinkedList<>();
playlist.add("Track 1");
playlist.add("Track 2");
System.out.println(playlist);
Note: Use Linked List when frequent insertion/deletion is needed.
4. Stack Data Structure
A stack is a data structure that follows the LIFO (Last In First Out) principle, which means the insertion and deletion of elements will happen from the top of the stack.
Real-Life Use Case
Stack is perfect for saving the browser history or for undo actions.
public class BrowserHistory {
public static void main(String[] args) {
Stack<String> history = new Stack<>();
history.push("youtube.com");
history.push("amazon.com");
history.push("canva.com");
history.push("vairagicodes.com");
System.out.println("Current Page:" + history.peek());
}
}
Output:
Note: Use stack for backtracking, undo-redo, or expression evaluation.
5. Queue Data Structure
A Queue is a data structure that follows the FIFO (First In First Out) principle, which means the enqueue (Insertion) will happen from the rear, and the dequeue (Deletion) will happen from the front.
Real-Life Use Case
A queue is perfect for a customer support ticket system.
public class RaiseTicket {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("Ticket 1");
queue.add("Ticket 2");
queue.add("Ticket 3");
System.out.println("Next in line: " + queue.peek());
}
}
Output:
Note: Queue is used for scheduling, print queues, or BFS algorithms.
6. Priority Queue Data Structure
A Priority Queue processes elements based on priority.
Real-Life Use Case
A Priority Queue is useful when you need to process tasks based on priority. Like in the Windows task manager, where we can set the priority of a task, and based on that, Windows will process that task.
public class PriorityBasedTask {
public static void main(String[] args) {
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(5);
pq.add(1);
pq.add(3);
System.out.println(pq.peek());
}
}
Note: Priority Queue is used when you need automatic sorting by custom priority
7. HashMap Data Structure
HashMap stores information in key-value pairs where the key is always unique and the value can be repeated. Like the user’s signup information.
When data is in a key-value pair, like students and their roll numbers or a country and its population, you can store this type of data in a HashMap.
Internal Structure Of HashMaps
Internally HashMaps are implemented using the array of LinkedList.
Real-Life Use Case
In the real world, HashMaps are used to store key-value type data, like user settings or configurations. (Or any other key-value pair data)
public class UserConfig {
public static void main(String[] args) {
HashMap<String, String> user = new HashMap<>();
user.put("name", "Krishna");
user.put("role", "Developer");
System.out.println(user.get("name"));
}
}
Note: HashMaps are used to store key-value pair data, and use HashMaps when quick search and mapping are needed.
8. HashSet Data Structure
A HashSet is a collection of unique elements with no duplicates. Let’s understand it using a real-life use case.
Real-Life Use Case
Suppose you want to track unique IP addresses visiting your app; then in this case, you can use a HashSet to store unique IP addresses visiting your website or app.
public class TrackIp {
public static void main(String[] args) {
HashSet<String> ipSet = new HashSet<>();
ipSet.add("192.168.0.1");
ipSet.add("192.168.0.1"); // Duplicate ignored
ipSet.add("192.168.0.2");
System.out.println(ipSet);
}
Output:
[192.168.0.1, 192.168.0.2]
9. Tree Data Structure
Let’s understand tree data structure with a real-life example. Suppose you are building an admin app for a college. So there you will find a certain hierarchy.
So to store this type of hierarchical data in a program, we use a tree data structure. A Tree is a non-linear hierarchical data structure that consists of nodes connected by edges.
Real-Life Use Case
To implement a directory structure or folder structure, we can use a tree data structure.
Java Code Snippet
class TreeNode {
int value;
TreeNode left, right;
TreeNode(int item) {
value = item;
left = right = null;
}
}
Note: Use tree when dealing with hierarchical data
10. Graph Data Structure
A graph is a non-linear data structure. it’s a collection of nodes that have data and are connected to other nodes.
Let’s understand a graph with a real-life example. Instagram is a great example where graph Data- Structure is used. Instagram uses graphs to store information about users.
Here, every user is a node just like in Graph. Suppose vairagi.codes follows thegeniusprogrammer and he also follows vairagi.codes then one undirected edge will be created between the two nodes.
Similarly vairagi.codes follows randomguy but the randomguy does not follow vairagi.codes so in that case directed edge will be created from vairagi.codes to randomguy.
In the third case, @randomguy2 follows vairagi.codes but vairagi.codes does not follow @randomguy2, so in that case, a directed edge will be created but this time pointing to vairagi.codes. This is how graph data structure works in social networking sites.
Similarly, Google Map is another example where Graphs are used. In Google Map, every location is considered as node, and roads between locations are considered as edges.
Real-Life Use Case
Graphs are used for friend suggestions in social apps.
Java Code Snippet
public class GraphExample {
public static void main(String[] args) {
Map<Integer, List<Integer>> graph = new HashMap<>();
graph.put(1, Arrays.asList(2, 3));
graph.put(2, Arrays.asList(1, 4));
System.out.println(graph);
}
}
Note: Use graphs in pathfinding, recommendation systems, and networks.
Recap: When To Use Which
| Data Structure | When to use |
|---|---|
Array |
elements are known and fixed |
Array-List |
when dealing with dynamic list of data |
Linked-List |
frequent insertion/deletion is needed |
Stack |
for backtracking, undo-redo, or expression evaluation |
Queue |
for scheduling, print queues, or BFS algorithms |
Priority Queue |
when you need automatic sorting by custom priority |
HashMap |
for key-value pair data |
HashSet |
to store unique value |
Tree |
when dealing with hierarchical data |
Graph |
in pathfinding, recommendation systems, and networks |
📥 Download Free PDF Cheat Sheet
🎁 Grab your free downloadable PDF:
👉 Get the free PDF cheat sheet to master the Top 10 Data Structures with real-life examples!
🧠 Final Thoughts
Learning data structures isn’t just for acing coding interviews—it’s for writing efficient and clean Java code. These 10 data structures cover almost every real-world use case you’ll encounter as a developer.
Which one is your favorite? Or which one confuses you the most?
Drop a comment below and let’s discuss!
Related Posts
Stay Connected
Follow me on Instagram for Java tips, coding reels, and much more.
Subscribe to my YouTube Channel for learning the art of programming.
