Java Program To Store Data In Structures Dynamically

In Java, handling data often requires structures that can grow or shrink as needed, adapting to varying amounts of information. This dynamic capability is crucial when the exact number of data elements isn't known beforehand. In this article, you will learn how to store and manage data efficiently using dynamic structures in Java, exploring common approaches and their practical applications.

Problem Statement

Traditional arrays in Java have a fixed size, meaning their capacity is set at the time of creation and cannot be changed. This limitation becomes problematic when dealing with scenarios where the number of data elements is unknown or fluctuates during program execution. For instance, if you need to store user inputs, a list of items in a shopping cart, or sensor readings, a static array might quickly become insufficient or waste memory. Without dynamic structures, developers face challenges like:

• Fixed Capacity: Inability to add more elements than initially allocated.
• Memory Inefficiency: Allocating a large array to anticipate maximum size might lead to wasted memory if few elements are stored, or ArrayIndexOutOfBoundsException if the maximum is underestimated.
• Manual Resizing: Manually creating new, larger arrays and copying elements is cumbersome and error-prone.

Example

Let's consider storing a list of student names. If we don't know how many students there will be, a dynamic structure like ArrayList provides a flexible solution. Here's a quick look at how it works and its output.

Initial Student List: []
Adding Alice
Adding Bob
Current Student List: [Alice, Bob]
Adding Charlie
Current Student List: [Alice, Bob, Charlie]
Student at index 1: Bob
Removing Bob
Final Student List: [Alice, Charlie]

Background & Knowledge Prerequisites

To effectively understand dynamic data structures in Java, familiarity with the following concepts is helpful:

• Basic Java Syntax: Variables, data types, operators, loops, and conditional statements.
• Object-Oriented Programming (OOP) Concepts: Classes, objects, methods, and encapsulation.
• Arrays: Understanding how fixed-size arrays work and their limitations.
• Generics (): Knowledge of how generics allow type-safe collections.
• Java Collections Framework: An overview of interfaces like List, Set, and Map.

For the examples, the primary imports will be from the java.util package, such as ArrayList, LinkedList, and HashMap. No specific setup beyond a standard Java Development Kit (JDK) is required.

Use Cases or Case Studies

Dynamic data structures are foundational to many applications. Here are a few practical examples:

• E-commerce Product Management: Storing a dynamic list of products available in a store, where new products are added and old ones removed frequently. An ArrayList or LinkedList can manage product objects.
• User Input Processing: Collecting an unknown number of user inputs, such as survey responses or a series of commands, where the input stream size isn't fixed.
• Implementing Queues and Stacks: Building fundamental data structures like queues (First-In, First-Out) for task scheduling or stacks (Last-In, First-Out) for undo functionalities. LinkedList is often used for these.
• Caching Systems: Storing frequently accessed data for quick retrieval, where the cached items change over time. HashMap is excellent for quick key-based lookups.
• Log Management: Collecting application logs, where new log entries are continually added to a growing list for analysis.

Solution Approaches

Java's Collections Framework provides several robust dynamic data structures. We will explore ArrayList, LinkedList, and HashMap due to their widespread use and distinct characteristics.

Approach 1: Using ArrayList

ArrayList is a resizable array implementation of the List interface. It's excellent for situations where you need fast random access to elements and frequent additions to the end of the list.

• One-line summary: A dynamic array that can grow and shrink, providing efficient random access.

// ArrayListExample
import java.util.ArrayList;
import java.util.List;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create an ArrayList to store String elements
        List<String> fruits = new ArrayList<>();
        System.out.println("Initial fruit list: " + fruits);

        // Step 2: Add elements to the ArrayList
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        System.out.println("After adding fruits: " + fruits);

        // Step 3: Access elements by index
        String firstFruit = fruits.get(0);
        System.out.println("First fruit: " + firstFruit);

        // Step 4: Check if an element exists
        boolean hasBanana = fruits.contains("Banana");
        System.out.println("Contains Banana? " + hasBanana);

        // Step 5: Remove an element by value or index
        fruits.remove("Banana"); // Removes "Banana"
        System.out.println("After removing Banana: " + fruits);

        // Step 6: Get the size of the ArrayList
        int numberOfFruits = fruits.size();
        System.out.println("Number of fruits: " + numberOfFruits);
    }
}

Run

Sample Output:

Initial fruit list: []
After adding fruits: [Apple, Banana, Cherry]
First fruit: Apple
Contains Banana? true
After removing Banana: [Apple, Cherry]
Number of fruits: 2

Stepwise Explanation:

1. An ArrayList named fruits is initialized to store String objects. The part is a generic type parameter, ensuring type safety.
2. The add() method is used to insert elements at the end of the list.
3. The get(index) method retrieves an element based on its zero-based index.
4. The contains() method checks for the presence of a specific element.
5. The remove() method can take either an object to remove its first occurrence or an index to remove the element at that position.
6. The size() method returns the current number of elements in the ArrayList.

Approach 2: Using LinkedList

LinkedList implements both List and Deque interfaces, making it suitable for scenarios requiring frequent insertions and deletions, especially at the beginning or end of the list. It stores elements as nodes, where each node contains the data and references to the next and previous nodes.

• One-line summary: A doubly linked list, optimized for fast insertions and deletions anywhere in the list.

// LinkedListExample
import java.util.LinkedList;
import java.util.List;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a LinkedList to store Integer elements
        List<Integer> numbers = new LinkedList<>();
        System.out.println("Initial number list: " + numbers);

        // Step 2: Add elements to the LinkedList
        numbers.add(10);
        numbers.add(20);
        numbers.addFirst(5); // Add to the beginning (specific to LinkedList)
        numbers.addLast(25);  // Add to the end (specific to LinkedList)
        System.out.println("After adding numbers: " + numbers);

        // Step 3: Access first and last elements
        int firstNum = ((LinkedList<Integer>) numbers).getFirst(); // Cast needed for getFirst()
        int lastNum = ((LinkedList<Integer>) numbers).getLast();   // Cast needed for getLast()
        System.out.println("First number: " + firstNum);
        System.out.println("Last number: " + lastNum);

        // Step 4: Remove elements
        numbers.remove(1); // Removes element at index 1 (value 10)
        numbers.removeFirst(); // Removes 5
        System.out.println("After removing elements: " + numbers);

        // Step 5: Get the size of the LinkedList
        int numberOfNumbers = numbers.size();
        System.out.println("Number of elements: " + numberOfNumbers);
    }
}

Run

Sample Output:

Initial number list: []
After adding numbers: [5, 10, 20, 25]
First number: 5
Last number: 25
After removing elements: [20, 25]
Number of elements: 2

Stepwise Explanation:

1. A LinkedList named numbers is created, storing Integer objects.
2. Elements are added using add(), addFirst(), and addLast(). addFirst() and addLast() are specific methods of LinkedList for efficient additions at the ends.
3. getFirst() and getLast() methods (available on LinkedList) retrieve elements from the beginning and end without removing them. A cast is necessary because the numbers variable is declared as List, which doesn't directly expose getFirst()/getLast().
4. Elements are removed using remove(index) or removeFirst(). removeLast() is also available.
5. The size() method returns the current count of elements.

Approach 3: Using HashMap

HashMap is an implementation of the Map interface, storing data in key-value pairs. It provides very efficient retrieval of values when their corresponding keys are known. Keys must be unique, while values can be duplicated.

• One-line summary: Stores data as key-value pairs, optimized for fast lookups, insertions, and deletions based on keys.

// HashMapExample
import java.util.HashMap;
import java.util.Map;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a HashMap to store String (key) and Integer (value) pairs
        Map<String, Integer> studentScores = new HashMap<>();
        System.out.println("Initial student scores: " + studentScores);

        // Step 2: Add key-value pairs to the HashMap
        studentScores.put("Alice", 95);
        studentScores.put("Bob", 88);
        studentScores.put("Charlie", 92);
        System.out.println("After adding scores: " + studentScores);

        // Step 3: Retrieve a value using its key
        int aliceScore = studentScores.get("Alice");
        System.out.println("Alice's score: " + aliceScore);

        // Step 4: Check if a key or value exists
        boolean hasBob = studentScores.containsKey("Bob");
        boolean hasScore90 = studentScores.containsValue(90);
        System.out.println("Contains Bob? " + hasBob);
        System.out.println("Contains score 90? " + hasScore90);

        // Step 5: Update a value
        studentScores.put("Bob", 90); // Overwrites Bob's previous score
        System.out.println("After updating Bob's score: " + studentScores);

        // Step 6: Remove a key-value pair
        studentScores.remove("Charlie");
        System.out.println("After removing Charlie: " + studentScores);

        // Step 7: Iterate through key-value pairs
        System.out.println("All scores:");
        for (Map.Entry<String, Integer> entry : studentScores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Run

Sample Output:

Initial student scores: {}
After adding scores: {Alice=95, Bob=88, Charlie=92}
Alice's score: 95
Contains Bob? true
Contains score 90? false
After updating Bob's score: {Alice=95, Bob=90, Charlie=92}
After removing Charlie: {Alice=95, Bob=90}
All scores:
Alice: 95
Bob: 90

Stepwise Explanation:

1. A HashMap named studentScores is created to map String keys (student names) to Integer values (their scores).
2. The put(key, value) method inserts or updates a key-value pair. If the key already exists, its value is updated.
3. The get(key) method retrieves the value associated with the specified key.
4. containsKey(key) and containsValue(value) check for the existence of a key or value, respectively.
5. Calling put() with an existing key will replace its associated value.
6. The remove(key) method deletes the entry corresponding to the specified key.
7. The entrySet() method returns a Set of Map.Entry objects, allowing iteration over all key-value pairs.

Conclusion

Dynamic data structures are indispensable tools in Java programming, offering flexibility and efficiency where static arrays fall short. By understanding and utilizing structures like ArrayList, LinkedList, and HashMap, developers can create robust applications that handle varying data loads effectively. Choosing the right structure depends on specific needs: ArrayList for fast random access, LinkedList for frequent insertions/deletions, and HashMap for quick key-based data retrieval.

Summary

• Dynamic vs. Static: Dynamic structures adapt their size during runtime, unlike fixed-size arrays.
• ArrayList: Best for fast element access by index and appending elements.
• LinkedList: Ideal for frequent insertions and deletions, especially at the beginning or end.
• HashMap: Excellent for storing and retrieving data in key-value pairs with fast lookups.
• Java Collections Framework: Provides a rich set of dynamic structures, making data management efficient and flexible.