What Are Different Data Structure in Java?

What Are Different Data Structures in Java?

When it comes to organizing and manipulating data in Java, data structures play a crucial role. A data structure is a way of storing and organizing data in memory, allowing efficient access and modification. In Java, there are several built-in data structures that you can use to solve various problems.

Array

Arrays are the most basic and widely used data structures in Java. They allow you to store a fixed-size sequence of elements of the same type. Elements in an array are accessed by their index, which starts from 0.

To declare an array in Java, you can use the following syntax:

    
        type[] arrayName = new type[size];
    

For example, to declare an integer array with a size of 5:

    
        int[] numbers = new int[5];
    

List

List is an interface in Java that represents an ordered collection of elements. There are several implementations of the List interface available in Java, such as ArrayList and LinkedList.

An ArrayList is a resizable dynamic array implementation of the List interface. It allows you to add or remove elements at any position within the list.

    
        import java.util.ArrayList;
        
        // Create an ArrayList
        ArrayList<String> names = new ArrayList<>();
        
        // Add elements to the list
        names.add("John");
        names.add("Alice");
        names.add("Bob");
        
        // Access elements by index
        String firstElement = names.get(0); // John
        
        // Remove an element
        names.remove(2); // Remove "Bob"
        
        // Print all elements
        for (String name : names) {
            System.out.println(name);
        }
    

LinkedList, on the other hand, is a doubly-linked list implementation of the List interface. It provides fast insertion and deletion operations at both ends but slower random access.

Set

Set is an interface in Java that represents a collection of unique elements. It does not allow duplicate values. There are several implementations of the Set interface available in Java, such as HashSet and TreeSet.

A HashSet is an unordered implementation of the Set interface based on hashing. It offers constant-time performance for basic operations like add, remove, and contains.HashSet;

// Create a HashSet
HashSet<String> uniqueNames = new HashSet<>();

// Add elements to the set
uniqueNames.add(“John”);
uniqueNames.add(“Alice”);
uniqueNames.add(“Bob”);

// Check if an element exists
boolean containsAlice = uniqueNames.contains(“Alice”); // true

// Remove an element
uniqueNames.remove(“John”);

// Print all elements
for (String name : uniqueNames) {
System.println(name);
}

A TreeSet is an ordered implementation of the Set interface based on a self-balancing binary search tree. It maintains its elements in sorted order.

Map

Map is an interface in Java that represents a collection of key-value pairs. Each key in a Map must be unique, and it can be used to retrieve the corresponding value.

There are several implementations of the Map interface available in Java, such as HashMap and TreeMap.

A HashMap is an unordered implementation of the Map interface based on hashing. It provides constant-time performance for basic operations like put, get, and remove.HashMap;

// Create a HashMap
HashMap<String, Integer> scores = new HashMap<>();

// Add key-value pairs to the map
scores.put(“John”, 90);
scores.put(“Alice”, 95);
scores.put(“Bob”, 80);

// Get the value associated with a key
int johnScore = scores.get(“John”); // 90

// Remove a key-value pair
scores.remove(“Bob”);

// Print all key-value pairs
for (String name : scores.keySet()) {
int score = scores.get(name);
System.println(name + “: ” + score);
}

A TreeMap is an ordered implementation of the Map interface based on a self-balancing binary search tree. It maintains its entries in sorted order based on the keys.

Conclusion

In this article, we explored different data structures available in Java. Arrays provide a fixed-size sequence of elements, Lists offer dynamic collections with ordered access, Sets ensure uniqueness of elements, and Maps store key-value pairs for efficient retrieval.

By understanding these data structures and their characteristics, you can choose the appropriate one for your specific programming needs and optimize your code accordingly. Happy coding!