Data Structures in Java

The numerous ways that data can be arranged, saved, and handled within a computer program are referred to as data structures in Java. These structures offer a methodical method for handling and managing data effectively, enabling useful operations like insertion, deletion, retrieval, and traversal.

The article will explore everything related to the data structures in Java, and it helps beginners to understand easily and effectively.

What is Java?
What are Data Structures in Java?
Types of Data Structures in Java
Advantages of Data Structures in Java
Classification of Data Structures
Data Structures in Java FAQs

What is Java?

Java is a popular object-oriented programming language renowned for its vast standard library and platform freedom. It offers a solid architecture for creating programs running without recompilation across various platforms. The well-known library for Java has a choice of records systems that make it viable to deal with numerous data types efficiently.

What are Data Structures in Java?

The way that data is organized and stored in a computer program's memory relies closely on Java records structures. The Java well-known library includes a significant type of built-in statistics structures. A few of the records systems that permit programmers short and simple ways to save and arrange data include connected lists, stacks, queues, and arrays. Developers can quickly perform operations like insertion, deletion, searching, and sorting because they provide a range of mechanisms for getting Access to, altering, and managing data. Java programmers can reduce memory use and considerably boost the overall efficiency of their programs by using these data structures.

Types of Data Structures in Java

The list of data structures in Java listed below

Arrays
ArrayList
LinkedList
Stack
Queue
HashMap
HashSet
TreeSet
TreeMap
Graph
Tree

The below diagram clearly explains the types of Data Structures in Java very clearly.

Further classification of types of Data Structures:

There are two types of Data Structures: -

Primitive Data Structures
Non-primitive Data Structures

1) Primitive Data Structures: Also known as primitive data types, these are basic built-in data types in Java. They include:

Byte: Stores whole numbers from -128 to 127.
short: Stores whole numbers from -32,768 to 32,767.
int: Stores whole numbers from -2,147,483,648 to 2,147,483,647.
float: Stores floating-point numbers with single precision.
char: Stores individual characters.
boolean: Stores true or false values.
long: Stores large whole numbers.
Double: Stores floating-factor numbers with double precision.

2) Non-primitive Data Structures: Non-primitive records structures are more complex and are composed of primitive information sorts. They may be, in addition, categorized into two sorts:

Linear Data Structures: In linear data structures, the elements are arranged linearly or sequentially. Examples include:
- Arrays: A group of identically-typed elements placed in an array according to a predetermined arrangement.
- Stacks: A Last-In-First-Out (LIFO) structure in which only the topmost items may be added or removed.
- Queues: First-In-First-Out (FIFO) structures are utilized in queues, where items are inserted on the returned and taken out on the front.
- Linked List: A related list comprises a collection of gadgets referred to as nodes, each of which has a reference to the node after it and statistics inside it.
Non-linear Data Structures: In non-linear data structures, the elements are arranged in a non-sequential manner. Examples include:
- Trees: Trees are a type of node-based hierarchical structure, with a root node at the top and child nodes branching out of it. Examples include red-black trees, AVL trees, binary search trees, and binary trees.
- Graphs: A set of nodes linked by using edges, wherein nodes may have any quantity of connections. Graphs are used to symbolize complex relationships among items.
- Heap: A specialized tree-based structure in which every determined node has a value more or smaller than its kids, relying on whether or not it is a max heap or a min heap.
- Hash: Data structures that use a hash function to map keys to values. Examples consist of hash sets and hash maps, which provide green retrieval and storage of statistics based on precise keys.

Advantages of Data Structures in Java

Efficient Data Organization: Data structures provide organized ways to store and manage data, allowing for efficient Access, manipulation, and retrieval operations. They optimize memory usage and facilitate faster execution of algorithms.
Better Performance: Developers can improve performance in terms of speed and memory utilization by selecting the suitable data structure for a particular activity. Performance is optimized because specific data structures are made to excel at particular actions like searching, sorting, or inserting information.
Code reusability: Java offers a wide range of built-in data structures that are simple for programmers to use. These reusable data structures save time and effort by removing the need to create sophisticated algorithms from scratch.
Code Simplicity: Data structures make the implementation of complicated processes simpler to code. They offer high-level abstractions and encapsulate the specifics of data management, which improves the code's readability, maintainability, and clarity.
Flexibility and Adaptability: Data structures offer flexibility in handling different types and sizes of data. They can dynamically adjust to accommodate changing data requirements and provide mechanisms for efficient data manipulation.
Standardized and Well-Tested: The standard library for Java contains built-in data structures that have undergone significant testing and optimization, guaranteeing their dependability and performance. Utilizing these common data structures lowers the possibility of errors and gives application development a solid foundation.
Scalability: Data structures provide scalability options, allowing applications to handle large volumes of data efficiently. They can dynamically grow or shrink based on the data size, ensuring optimal performance even with increasing data demands.
Algorithm Design: Data structures are crucial in algorithm design and analysis. They provide the underlying structure and operations necessary for implementing various algorithms and solving complex problems.

1) Arrays:

An array is a basic and often used data structure in the context of Java's data structures. It offers a method of storing a fixed-size collection of identical-type components. Because they provide quick and easy access to elements depending on their index, arrays are a crucial tool for managing and organizing data.

Advantages:

Data Organization: Arrays provide a structured way to store and organize elements, improving data management.
Random Access: Elements can be accessed directly using their index, allowing for efficient retrieval and modification.
Fixed Size: Arrays have a predetermined size, enabling efficient memory allocation.
Homogeneous Elements: Arrays store elements of the same type, ensuring data consistency and simplifying operations.
Iteration: Arrays support easy iteration through elements, facilitating traversal and processing.
Sorting and Searching: Arrays work well with sorting and searching algorithms, offering efficient operations.
Memory Efficiency: Arrays optimize memory usage by storing elements in contiguous regions.
Compatibility: Arrays are widely supported in Java, making them compatible with various frameworks and tools.

Disadvantages:

Fixed Size: Arrays cannot be dynamically resized, requiring recreation for size changes.
Memory Wastage: Unused elements in larger arrays can lead to memory wastage.
Insertion and Deletion Overhead: Inserting or deleting elements in the middle of an array requires shifting subsequent elements, resulting in inefficiency.
Lack of Flexibility: Arrays have rigid data types and cannot accommodate different data kinds without additional arrays or data structures.

Functions:

Creating an Array: Declare and initialize an array with a specific size using the array type and the new keyword.
Accessing Elements: Use the index to access individual elements in the array.
Modifying Elements: Update the value of an element by assigning a new value to a specific index in the array.
Finding Length: Use the length attribute to determine the array's length.
Iterating through the Array: Use loops to go through each element in the array and execute

Implementation:

FileName: ArrayExample.java

import java.util.*;

public class ArrayExample 
{
    public static void main(String[] args) 
    {
        int[] numbers={10,20,30,40,50}; // Initialize an array of integers
        
        System.out.println("Element at index 0:"+numbers[0]);
        System.out.println("Element at index 2:"+numbers[2]);
        System.out.println("Element at index 4:"+numbers[4]);
        
        int sum=0;
        for (int i=0;i<numbers.length;i++) 
        {
            sum+=numbers[i];
        }
        System.out.println("Sum of array elements:"+sum);
        
        numbers[2]=35; // Update an element in the array
        
        System.out.println("Updated element at index 2:"+numbers[2]);
        
        System.out.println("Elements in the array:");
        for (int number:numbers) 
        {
            System.out.println(number);
        }
    }
}

Output:

Element at index 0:10
Element at index 2:30
Element at index 4:50
Sum of array elements:150
Updated element at index 2:35
Elements in the array:
10
20
35
40
50

2) ArrayList:

ArrayList in Java is a dynamic data structure that allows for the storage and manipulation of elements. It is part of the Java Collections Framework and is implemented using an array internally.

Advantages:

Dynamic Size: Unlike arrays, ArrayLists can dynamically grow or shrink in size as elements are added or removed. It eliminates the need for manual resizing and allows for handling varying amounts of data conveniently.
Easy Element Manipulation: ArrayLists offer methods to add, remove, and modify elements at any position within the list. Its flexibility simplifies common operations such as insertion, deletion, and updating, making element manipulation more efficient.
Random Access: ArrayLists support random Access to elements using their index, enabling quick retrieval and modification of elements at specific positions within the list. It facilitates efficient element access and enhances overall performance.
Compatibility with Java Collection Framework: ArrayLists implement the List interface, making them compatible with other Collection classes in the Java Collections Framework. Its compatibility allows for seamless integration with various algorithms and operations provided by the framework.

Disadvantages:

Higher Memory Overhead: ArrayLists require additional memory to maintain their internal structure, resulting in higher memory overhead compared to arrays. It can be a concern when dealing with large collections of elements.
Slower Insertion and Deletion: Inserting or deleting elements in the middle of an ArrayList requires shifting elements, which can be time-consuming for large lists. In scenarios where frequent insertion or deletion operations are expected, other data structures like LinkedList may offer better performance.
Limited Performance for Search: Searching for an element in an unsorted ArrayList requires iterating over the elements until a match is found. It is a linear search approach that results in slower search performance compared to data structures optimized for searching, such as HashSet or TreeMap.
No Primitive Type Support: ArrayLists can only store objects and do not directly support primitive data types like int or char. To store primitive types, wrapper classes like Integer or Character need to be used, leading to potential autoboxing and unboxing overhead.

Functions:

Creating an ArrayList: Declare and initialize an ArrayList using the ArrayList class and specify the element type within the angle brackets.
Adding Elements: Use the add method to append elements at the end of the ArrayList.
Accessing Elements: Use the get technique to retrieve the price of detail at a selected index.
Modifying Elements: Update the cost of detail at a specific index for the usage of the set approach.
Finding Size: Use the dimensions method to get the cutting-edge quantity of factors in the ArrayList.
Removing Elements: Use the remove approach to delete a detail at a specific index or via providing the object reference.
Iterating through the ArrayList: Use loops to iterate over each element in the ArrayList and perform operations on them.

Implementation:

FileName: ArrayListExample.java

import java.util.*;

public class ArrayListExample 
{
    public static void main(String[] args) 
    {
        // Create an ArrayList to store integers
        ArrayList<Integer> numbers=new ArrayList<>(List.of(10,20,30,40,50));

        //Access and print elements from the ArrayList
        System.out.println("Element at index 0:"+numbers.get(0));
        System.out.println("Element at index 2:"+numbers.get(2));
        System.out.println("Element at index 4:"+numbers.get(4));

        // Calculate and print the sum of all elements in the ArrayList
        int sum=numbers.stream().mapToInt(Integer::intValue).sum();
        System.out.println("Sum of ArrayList elements:"+sum);

        // Update an element in the ArrayList
        numbers.set(2,35);
        System.out.println("Updated element at index 2:"+numbers.get(2));

        // Iterate through the ArrayList using a for-each loop and print the elements
        System.out.println("Elements in the ArrayList:");
        for (int number:numbers) 
        {
            System.out.println(number);
        }
    }
}

Output:

Element at index 0:10
Element at index 2:30
Element at index 4:50
Sum of ArrayList elements:150
Updated element at index 2:35
Elements in the ArrayList:
10
20
35
40
50

3) Linked List:

A linked list is a linear data structure in which elements are stored in separate objects called nodes. A reference link to the following node in the sequence is included in each node's data element. The list's final node links to null, indicating that the list has ended.

Unlike arrays, linked lists do not require contiguous memory allocation. Each node in a linked list can be allocated independently, allowing for dynamic memory allocation and efficient insertion and deletion operations.

Advantages:

Dynamic Size: LinkedList can grow or shrink dynamically, making it suitable for varying or unknown data sizes.
Efficient Insertion and Deletion: Inserting or deleting elements within a LinkedList is efficient, as it does not require shifting elements.
No Contiguous Memory Requirement: LinkedList does not need contiguous memory allocation, making it flexible and suitable for unpredictable memory situations.
Easy Modification: LinkedList allows easy modification of elements by changing reference pointers, enabling efficient manipulation.

Disadvantages:

Slower Random Access: LinkedList has slower random Access as it requires traversing the list to access elements by index.
Increased Memory Overhead: LinkedList requires additional memory for references and nodes, increasing memory overhead compared to arrays.
Inefficient Search: LinkedList has slower search operations, requiring sequential iteration to find specific elements.

Functions:

Creating a LinkedList: Declare and initialize a LinkedList using the LinkedList class.
Adding Elements: Use the add method to append elements at the end of the LinkedList.
Accessing Elements: Use the get method to retrieve the value of an element at a specific index.
Modifying Elements: Update the value of an element at a particular index using the set method.
Removing Elements: Use the remove method to delete an element at a specific index or by providing the object reference.

Implementation:

FileName: LinkedList1.java

import java.util.*;

public class LinkedList1
{
    public static void main(String[] args) 
    {
        
        // Create a LinkedList to store integers
        LinkedList<Integer> linkedList1 = new LinkedList<>();

        // Add elements to the LinkedList
        linkedList1.add(10);
        linkedList1.add(20);
        linkedList1.add(30);
        linkedList1.add(40);
        linkedList1.add(50);

        // Print the LinkedList
        System.out.println("LinkedList:"+linkedList1);

        // Remove an element from the LinkedList
        linkedList1.removeFirst();
        System.out.println("LinkedList after removing first element:"+linkedList1);

        // Check if an element exists in the LinkedList
        boolean containsElement=linkedList1.contains(30);
        System.out.println("LinkedList contains element 30?"+containsElement);

        // Get the first and last elements of the LinkedList
        int firstElement=linkedList1.getFirst();
        int lastElement=linkedList1.getLast();
        System.out.println("First element:"+firstElement);
        System.out.println("Last element:"+lastElement);

        // Clear the LinkedList
        linkedList1.clear();
        System.out.println("LinkedList after clearing:"+linkedList1);
    }
}

Output:

LinkedList:[10, 20, 30, 40, 50]
LinkedList after removing first element:[20, 30, 40, 50]
LinkedList contains element 30?true
First element:20
Last element:50
LinkedList after clearing:[]

4) Stack:

The Last-In-First-Out (LIFO) principle dictates that the element that was most recently inserted is also the element that is removed first. A stack is a linear data structure that follows this rule. It employs the commands "push" and "pop" to add elements to the stack and, accordingly, remove the top element from the stack. The "peek" technique additionally enables Access to the top element without removing it.

Features of a stack:

LIFO behavior: The last element pushed onto the stack is the first one to be popped out, making it suitable for applications where the order of insertion and removal is important.
Limited Access: Stacks typically provide restricted Access to elements. You can only access the topmost element, and to reach other elements, you need to pop the elements above them.
Dynamic size: Stacks can be implemented using arrays or linked lists, allowing for a dynamic size. They can grow or shrink as needed during runtime.

Advantages:

Simplicity: Stacks are easy to understand and implement.
Efficiency: Insertion and deletion operations have a time complexity of O(1).
Function call management: Stacks efficiently manage function calls and variable storage.
Undo/Redo functionality: Stacks enable undo and redo operations in applications.

Disadvantages:

Limited Access: Access to elements is restricted to the top of the stack.
Size restrictions: Stacks may have size limitations depending on the implementation.
Not suitable for all scenarios: Stacks are specific to LIFO behavior and may not be appropriate in other cases.

Implementation:

FileName: StackExample.java

import java.util.Stack;

public class StackExample 
{
    public static void main(String[] args) 
    {
        // Create a stack
        Stack<Integer> stack=new Stack<>();

        // Push elements onto the stack
        stack.push(10);
        stack.push(20);
        stack.push(30);

        // Print the top element of the stack
        System.out.println("Top element:"+stack.peek());

        // Pop elements from the stack
        int poppedElement=stack.pop();
        System.out.println("Popped element:"+poppedElement);

        // Check if the stack is empty
        System.out.println("Is stack empty?"+stack.isEmpty());

        // Get the size of the stack
        System.out.println("Stack size:"+stack.size());

        // Iterate over the stack
        System.out.println("Stack elements:");
        for (Integer element:stack) 
        {
            System.out.println(element);
        }
    }
}

Output:

Top element:30
Popped element:30
Is stack empty?false
Stack size:2
Stack elements:
10
20

5) Queue:

A queue is a linear data structure in Java that follows the First-In-First-Out (FIFO) principle. It represents a collection of elements where elements are inserted at the rear and removed from the front.

Features:

Enqueue: Adding an element to the rear of the queue.
Dequeue: Removing an element from the front of the queue.
Peek: Retrieve the element at the front of the queue without removing it.
Size: Determining the number of elements in the queue.
Empty Check: Checking if the queue is empty.

Advantages:

FIFO Behavior: Elements are processed in the order of their insertion, ensuring the preservation of the original sequence.
Efficient Insertion and Removal: Adding and removing elements from a queue is fast and has a constant time complexity of O(1).
Synchronization: Java provides synchronized queue implementations, making them safe for concurrent programming.
Standardized Interface: The Queue interface in Java offers a common set of methods, allowing easy interchangeability between different queue implementations.

Disadvantages:

No Random Access: Queues do not support direct Access to elements in the middle. Accessing specific positions requires dequeuing preceding elements.
Limited Size: Some queue implementations have a fixed size or capacity, leading to overflow or exceptions when exceeding the maximum size.
Inefficient Search: Searching for an element in a queue requires dequeuing until a match is found, resulting in a linear search with potentially high time complexity.

Implementation:

FileName: QueueExample.java

import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;

public class QueueExample 
{
    public static void main(String[] args) 
    {
        // Create a Queue to store integers
        Queue<Integer> queue=new LinkedList<>();

        // Enqueue elements to the Queue
        queue.offer(10);
        queue.offer(20);
        queue.offer(30);
        queue.offer(40);
        queue.offer(50);

        //Access and print the front element of the Queue
        System.out.println("Front element:"+queue.peek());

        // Dequeue elements from the Queue and print them
        while (!queue.isEmpty()) 
        {
            int element=queue.poll();
            System.out.println("Dequeued element:"+element);
        }
    }
}

Output:

Front element:10
Dequeued element:10
Dequeued element:20
Dequeued element:30
Dequeued element:40
Dequeued element:50

6) HashMap:

A HashMap is a data structure in Java that provides a way to store and retrieve key-value pairs. It is part of the Java Collections Framework and is implemented based on the hash table data structure.

Functions:

put(key, value): Inserts the specified key-value pair into the HashMap.
get(key): Retrieves the value associated with the specified key.
containsKey(key): Checks if the HashMap contains the specified key.
containsValue(value): Checks if the HashMap contains the specified value.
remove(key): Removes the key-value pair associated with the specified key from the HashMap.
size(): Returns the number of key-value pairs in the HashMap.
isEmpty(): Checks if the HashMap is empty.
keySet(): Returns a Set containing all the keys in the HashMap.
values(): Returns a Collection containing all the values in the HashMap.
clear(): Removes all the key-value pairs from the HashMap.

Advantages:

Efficient Retrieval: HashMap provides fast retrieval of values based on keys with constant-time complexity O(1).
Flexible Key-Value Pairing: HashMap allows any non-null object as a key, enabling custom-defined keys for storing and retrieving data.
Dynamic Size: HashMap can dynamically grow or shrink in size to handle varying amounts of data.
Compatibility with Java Collections Framework: HashMap implements the Map interface, allowing seamless integration with other Collection classes.

Disadvantages:

Lack of Ordering: HashMap does not preserve the order of elements. Use LinkedHashMap or TreeMap for specific ordering requirements.
Increased Memory Overhead: HashMap requires additional memory for hash codes and internal structure compared to simpler data structures.
Slower Iteration: Iterating over a HashMap can be slower compared to arrays or lists due to traversing the underlying hash table.

Implementation:

FileName: HashMapExample.java

import java.util.HashMap;

public class HashMapExample 
{
    public static void main(String[] args) {
        // Create a HashMap to store String keys and Integer values
        HashMap<String, Integer> hashMap=new HashMap<>();

        // Add key-value pairs to the HashMap
        hashMap.put("John",25);
        hashMap.put("Alice",30);
        hashMap.put("Bob",35);

        //Access and print values based on keys
        System.out.println("Age of John:"+hashMap.get("John"));
        System.out.println("Age of Alice:"+hashMap.get("Alice"));

        // Check if a key exists in the HashMap
        System.out.println("Is Bob present?"+hashMap.containsKey("Bob"));

        // Update the value associated with a key
        hashMap.put("Alice",32);

        // Remove a key-value pair from the HashMap
        hashMap.remove("John");

        // Print all key-value pairs in the HashMap
        System.out.println("Key-Value pairs in the HashMap:");
        for (String key : hashMap.keySet()) 
        {
            System.out.println(key+":"+hashMap.get(key));
        }

        // Check the size of the HashMap
        System.out.println("Size of the HashMap:"+hashMap.size());
    }
}

Output:

Age of John:25
Age of Alice:30
Is Bob present?true
Key-Value pairs in the HashMap:
Bob:35
Alice:32
Size of the HashMap:2

7) HashSet:

HashSet is a data structure in Java that implements the Set interface and stores elements in a hash table.

Features:

Stores unique elements: HashSet does not allow duplicate elements. Each element in the HashSet is unique.
Uses hash-based lookup: HashSet uses the hash value of each element to determine its storage location, providing efficient element retrieval.
Unordered collection: The elements in a HashSet are not stored in a specific order. The order of elements may change over time.

Advantages:

Fast element lookup: HashSet provides fast lookup operations, making it efficient to check if an element exists in the set.
No duplicate elements: HashSet automatically handles duplicate elements and ensures that each element is unique.
Integration with Java Collections Framework: HashSet implements the Set interface, making it compatible with other collection classes in the Java Collections Framework.

Disadvantages:

No guaranteed order: HashSet does not maintain the order of elements. If the order of elements is important, HashSet is not suitable.
No indexing: HashSet does not provide direct indexing or positional Access to elements. To access elements, you need to iterate over the set.
Higher memory overhead: HashSet requires additional memory to store hash values and maintain the hash table structure, resulting in higher memory usage compared to some other data structures.

Implementation:

FileName: HashSetExample.java

import java.util.HashSet;

public class HashSetExample 
{
    public static void main(String[] args) 
    {
        // Create a HashSet
        HashSet<String> set=new HashSet<>();

        // Add elements to the HashSet
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Grapes");
        set.add("Mango");

        // Print the HashSet
        System.out.println("HashSet:"+set);

        // Check if an element exists
        System.out.println("Contains 'Apple':"+set.contains("Apple"));

        // Remove an element
        set.remove("Banana");

        // Print the updated HashSet
        System.out.println("Updated HashSet:"+set);

        // Get the size of the HashSet
        System.out.println("Size of HashSet:"+set.size());

        // Clear the HashSet
        set.clear();

        // Check if the HashSet is empty
        System.out.println("Is HashSet empty?"+set.isEmpty());
    }
}

Output:

HashSet:[Apple, Grapes, Mango, Orange, Banana]
Contains 'Apple':true
Updated HashSet:[Apple, Grapes, Mango, Orange]
Size of HashSet:4
Is HashSet empty?true

8) TreeSet:

TreeSet is an implementation of the SortedSet interface in Java that uses a self-balancing binary search tree called a red-black tree to store elements in sorted order.

Advantages:

Sorted Order: TreeSet automatically maintains the elements in a sorted order based on their natural ordering or a custom comparator. It allows for efficient searching and retrieval of elements in ascending or descending order.
No Duplicate Elements: TreeSet does not allow duplicate elements. It ensures that each element in the set is unique, which can be useful in scenarios where duplicate values should be avoided.
Efficient Operations: TreeSet provides efficient operations like insertion, deletion, and searching. These operations have a time complexity of O(log n), where n is the number of elements in the set.
Navigable Set Operations: TreeSet provides additional navigational methods, such as higher(), lower(), ceiling(), and floor(), which allow you to find elements that are greater than, less than, or equal to a given value.

Disadvantages:

Overhead: TreeSet requires additional memory to store the internal data structure, which can lead to higher memory overhead compared to other set implementations.
Slower Insertion and Removal: Insertion and removal operations in TreeSet involve maintaining the sorted order of elements, which may require tree restructuring. It can make these operations slightly slower compared to HashSet or LinkedHashSet.
Limited Customization: TreeSet is primarily designed for natural ordering or a single custom comparator. It may need more flexibility for multiple sorting criteria or complex sorting logic.

Functions:

add(element): Adds an element to the TreeSet while maintaining the sorted order.
remove(element): Removes the specified element from the TreeSet.
contains(element): Checks if the TreeSet contains the specified element.
size(): Returns the number of elements in the TreeSet.
first(): Returns the first (lowest) element in the TreeSet.
last(): Returns the last (highest) element in the TreeSet.
higher(element): Returns the least element in the TreeSet that is strictly greater than the given element.
lower(element): Returns the greatest element in the TreeSet that is strictly less than the given element.

Implementation:

FileName: TreeSetExample.java

import java.util.TreeSet;

public class TreeSetExample 
{
    public static void main(String[] args) 
    {
        // Create a TreeSet
        TreeSet<Integer> numbers=new TreeSet<>();

        // Add elements to the TreeSet
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);
        numbers.add(4);

        // Print the TreeSet
        System.out.println("Elements in the TreeSet:"+numbers);

        // Check if an element exists
        System.out.println("Does TreeSet contain 4?"+numbers.contains(4));

        // Remove an element
        numbers.remove(2);

        // Print the TreeSet after removal
        System.out.println("Elements in the TreeSet after removal:"+numbers);

        // Get the size of the TreeSet
        System.out.println("Size of the TreeSet:"+numbers.size());

        // Get the first and last element
        System.out.println("First element:"+numbers.first());
        System.out.println("Last element:"+numbers.last());

        // Iterate over the TreeSet
        System.out.println("Iterating over the TreeSet:");
        for (int number:numbers) 
        {
            System.out.println(number);
        }
    }
}

Output:

Elements in the TreeSet:[1, 2, 4, 5, 8]
Does TreeSet contain 4? true
Elements in the TreeSet after removal:[1, 4, 5, 8]
Size of the TreeSet:4First element:1
Last element:8
Iterating over the TreeSet:
1
4
5
8

9) TreeMap:

TreeMap is a class in Java that implements the Map interface and provides a sorted key-value mapping based on the natural order of the keys or a custom comparator.

Advantages:

Sorted Ordering: TreeMap maintains the keys in sorted order, which allows for efficient searching, retrieval, and range-based operations.
Key-Value Mapping: TreeMap stores key-value pairs, enabling efficient lookup and retrieval of values based on the associated keys.
Red-Black Tree Implementation: TreeMap uses a balanced binary search tree (Red-Black Tree) internally, ensuring efficient performance even for large datasets.
Support for Custom Comparators: TreeMap allows the use of custom comparators to define the sorting order of the keys, providing flexibility in sorting criteria.

Disadvantages:

Memory Overhead: TreeMap requires additional memory to store the internal tree structure and associated objects, resulting in higher memory usage compared to simpler data structures like HashMap.
Slower Insertion and Deletion: Insertion and deletion operations in TreeMap have a time complexity of O(log n) due to the need for tree restructuring, making them slower compared to HashMap or LinkedHashMap.
Limited Performance for Unsorted Data: TreeMap performs efficiently for sorted data, but its performance can degrade when dealing with unsorted data or frequent modifications, as it requires maintaining the sorted order.

Functions:

put(key, value): Inserts a key-value pair into the TreeMap.
get(key): Retrieves the value associated with the specified key.
containsKey(key): Checks if the TreeMap contains a specific key.
remove(key): Removes the key-value pair associated with the specified key.
size(): Returns the number of key-value pairs in the TreeMap.
keySet(): Returns a set of all keys in the TreeMap.
values(): Returns a collection of all values in the TreeMap.
entrySet(): Returns a set of key-value pairs in the TreeMap.

Implementation:

FileName: TreeMapExample.java

import java.util.TreeMap;

public class TreeMapExample 
{
    public static void main(String[] args) 
    {
        // Create a TreeMap
        TreeMap<String,Integer> scores=new TreeMap<>();

        // Insert key-value pairs into the TreeMap
        scores.put("Alice",90);
        scores.put("Bob",80);
        scores.put("Charlie",95);
        scores.put("David",87);
        scores.put("Eve",92);

        //Access and print values from the TreeMap
        System.out.println("Score of Alice:"+scores.get("Alice"));
        System.out.println("Score of Charlie:"+scores.get("Charlie"));
        System.out.println("Score of David:"+scores.get("David"));

        // Update a value in the TreeMap
        scores.put("Bob",85);

        // Remove a key-value pair from the TreeMap
        scores.remove("Eve");

        // Iterate through the TreeMap using a for-each loop
        System.out.println("Scores in the TreeMap:");
        for (String name:scores.keySet()) 
        {
            int score=scores.get(name);
            System.out.println(name+":"+score);
        }
    }
}

Output:

Score of Alice:90
Score of Charlie:95
Score of David:87
Scores in the TreeMap:
Alice:90
Bob:85
Charlie:95
David:87

10) Graph:

Graphs are data structure that represents a collection of interconnected nodes or vertices. They are composed of vertices and edges, where vertices represent entities and edges represent the relationships between those entities.

Advantages:

Versatility: Graphs can represent a wide range of real-world scenarios, making them suitable for various applications such as social networks, transportation systems, and computer networks.
Relationship Representation: Graphs provide a natural way to represent relationships and connections between entities, allowing for efficient analysis and traversal of these relationships.
Efficient Search and Traversal: Graph algorithms like breadth-first search (BFS) and depth-first search (DFS) enable efficient traversal and searching of the graph's vertices and edges.
Modeling Complex Relationships: Graphs can model complex relationships, including hierarchical structures, cyclic dependencies, and multiple connections between entities.

Disadvantages:

Space Complexity: Graphs can consume a significant amount of memory, especially large-scale graphs with many vertices and edges.
The complexity of Operations: Certain graph operations, such as finding the shortest path or detecting cycles, can have high time complexity, particularly in dense graphs.
Difficulty in Maintenance: Modifying or updating a graph can be complex, as changes in the graph's structure may impact its connectivity and existing algorithms.

Implementation:

FileName: GraphExample.java

import java.util.*;

public class GraphExample 
{
    private int V; // Number of vertices
    private List<List<Integer>> adjacencyList; // Adjacency list representation

    public GraphExample(int V) 
    {
        this.V=V;
        adjacencyList=new ArrayList<>(V);

        // Initialize the adjacency list
        for (int i=0;i<V;i++) 
        {
            adjacencyList.add(new ArrayList<>());
        }
    }

    // Function to add an edge between two vertices
    public void addEdge(int source,int destination) 
    {
        adjacencyList.get(source).add(destination);
        adjacencyList.get(destination).add(source);
    }

    // Function to perform Breadth-First Search traversal of the graph
    public void bfs(int startVertex) 
    {
        boolean[] visited=new boolean[V];
        Queue<Integer> queue=new LinkedList<>();

        visited[startVertex]=true;
        queue.add(startVertex);

        while (!queue.isEmpty()) 
        {
            int currentVertex=queue.poll();
            System.out.print(currentVertex+" ");

            List<Integer> neighbors=adjacencyList.get(currentVertex);
            for (int neighbor:neighbors) 
            {
                if (!visited[neighbor]) 
                {
                    visited[neighbor]=true;
                    queue.add(neighbor);
                }
            }
        }
        System.out.println();
    }

    // Function to perform Depth-First Search traversal of the graph
    public void dfs(int startVertex) 
    {
        boolean[] visited=new boolean[V];
        dfsUtil(startVertex,visited);
        System.out.println();
    }

    private void dfsUtil(int vertex,boolean[] visited) 
    {
        visited[vertex]=true;
        System.out.print(vertex+" ");

        List<Integer> neighbors=adjacencyList.get(vertex);
        for (int neighbor:neighbors) 
        {
            if (!visited[neighbor]) 
            {
                dfsUtil(neighbor,visited);
            }
        }
    }

    public static void main(String[] args) 
    {
        int V=5; // Number of vertices
        GraphExample graph=new GraphExample(V);

        // Add edges
        graph.addEdge(0,1);
        graph.addEdge(0,2);
        graph.addEdge(1,3);
        graph.addEdge(2,3);
        graph.addEdge(2,4);

        System.out.print("BFS traversal: ");
        graph.bfs(0);

        System.out.print("DFS traversal: ");
        graph.dfs(0);
    }
}

Output:

BFS traversal: 0 1 2 3 4 
DFS traversal: 0 1 3 2 4

11) Tree:

A tree is a widely used data structure in computer science that represents a hierarchical structure. It consists of nodes connected by edges, where each node can have zero or more child nodes.

Advantages:

Hierarchical Structure: Trees provide a natural way to represent hierarchical relationships, such as file systems, organization charts, or HTML/XML documents.
Efficient Search: Binary search trees enable efficient searching with a time complexity of O(log n), making them suitable for storing and retrieving sorted data.
Fast Insertion and Deletion: Tree data structures offer efficient insertion and deletion operations, especially when balanced, such as AVL trees or Red-Black trees.
Ordered Iteration: In-order traversal of a binary search tree gives elements in a sorted order, which is helpful for tasks like printing elements in sorted order or finding the next/previous element.

Disadvantages:

High Memory Overhead: Trees require additional memory to store node references or pointers, which can result in higher memory usage compared to linear data structures like arrays or lists.
Complex Implementation: Implementing and maintaining a tree data structure can be more complex compared to other data structures like arrays or lists, especially for balanced tree variants.
Limited Operations: Some tree variants, like binary search trees, do not support efficient operations like finding the kth smallest element or finding the rank of an element.

Functions:

Insertion: Add a new node to the tree.
Deletion: Remove a node from the tree.
Search: Find a specific node or element in the tree.
Traversal: Traverse the tree in different orders, such as in-order, pre-order, or post-order.
Height/Depth: Calculate the height or depth of the tree.
Balance: Ensure the tree remains balanced to maintain efficient operations.

Implementation:

FileName: TreeExample.java

import java.util.*;

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    public TreeNode(int value) {
        this.value = value;
        left = null;
        right = null;
    }
}

public class TreeExample 
{
    public static void main(String[] args) {
        // Create a binary search tree
        TreeNode root = new TreeNode(50);
        root.left = new TreeNode(30);
        root.right = new TreeNode(70);
        root.left.left = new TreeNode(20);
        root.left.right = new TreeNode(40);
        root.right.left = new TreeNode(60);
        root.right.right = new TreeNode(80);

        // Perform common operations
        System.out.println("In-order Traversal:");
        inOrderTraversal(root);

        System.out.println("\nSearch for value 40: "+search(root, 40));
        System.out.println("Search for value 90: "+search(root, 90));

        int minValue = findMinValue(root);
        System.out.println("Minimum value in the tree: "+minValue);

        int maxValue = findMaxValue(root);
        System.out.println("Maximum value in the tree: "+maxValue);
    }

    // In-order traversal: left subtree, root, right subtree
    public static void inOrderTraversal(TreeNode node) {
        if (node != null) {
            inOrderTraversal(node.left);
            System.out.print(node.value + " ");
            inOrderTraversal(node.right);
        }
    }

    // Search for a value in the tree
    public static boolean search(TreeNode node, int value) {
        if (node == null)
            return false;
        if (node.value == value)
            return true;
        if (value < node.value)
            return search(node.left, value);
        else
            return search(node.right, value);
    }

    // Find the minimum value in the tree
    public static int findMinValue(TreeNode node) {
        if (node.left == null)
            return node.value;
        return findMinValue(node.left);
    }

    // Find the maximum value in the tree
    public static int findMaxValue(TreeNode node) {
        if (node.right == null)
            return node.value;
        return findMaxValue(node.right);
    }
}

Output:

In-order Traversal:20 30 40 50 60 70 80 
Search for value 40: true
Search for value 90: false
Minimum value in the tree: 20
Maximum value in the tree: 80

Next TopicGeneric Type Casting In Java

← prev next →