Add classes for ArrayList exercises

Author: squidmin

src/main/java/collections/arraylist/ArrayListExercises.java renamed to src/main/java/collections/arraylist/ArrayListComparableExercise.java

@@ -2,10 +2,9 @@
 
 import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.Iterator;
 import java.util.List;
 
-public class ArrayListExercises {
+public class ArrayListComparableExercise {
 
     static class Employee implements Comparable<Employee> {
         String name;

src/main/java/collections/arraylist/ArrayListComparatorDemo2.java

@@ -6,7 +6,6 @@
 import java.util.List;
 
 class Vehicle4 {
-
     String brand;
     Integer makeYear;
 
@@ -27,7 +26,6 @@ public static void main(String[] args) {
         list.add(new Vehicle4("BMW", 2015));
         System.out.println("Sorting by brand name");
         Collections.sort(list, new Comparator<Vehicle4>() {
-
             @Override
             public int compare(Vehicle4 o1, Vehicle4 o2) {
                 return o1.brand.compareTo(o2.brand);
@@ -40,7 +38,6 @@ public int compare(Vehicle4 o1, Vehicle4 o2) {
 
         System.out.println("Sorting by make year");
         Collections.sort(list, new Comparator<Vehicle4>() {
-
             @Override
             public int compare(Vehicle4 o1, Vehicle4 o2) {
                 return o1.makeYear.compareTo(o2.makeYear);

src/main/java/collections/arraylist/ArrayListComparatorDemo3.java

@@ -5,7 +5,6 @@
 import java.util.List;
 
 class Vehicle5 {
-
     String brand;
     Integer makeYear;
 

src/main/java/collections/arraylist/docs/exercises.md

@@ -1,6 +1,6 @@
 # `ArrayList` exercises
 
-## Java Exercise 1: Implement Comparable for Sorting Custom Objects
+## Exercise 1: Implement Comparable for Sorting Custom Objects
 
 **Objective**: Learn how to use the `Comparable` interface to sort custom objects in Java.
 
@@ -22,7 +22,7 @@ Each `Student` object has two properties:
 
 ---
 
-## Java Exercise 2: Custom Sorting with Multiple Conditions
+## Exercise 2: Custom Sorting with Multiple Conditions
 
 **Objective**: Expand your understanding of the `Comparable` interface by implementing custom sorting logic that uses multiple conditions.
 
@@ -44,31 +44,71 @@ If two books were published in the same year, secondary sorting should be based
 
 ---
 
-## Java Exercise 3: Understanding the Importance of Consistency with equals
+## Exercise 3: Basic ArrayList Operations
 
-**Objective**: Understand the importance of consistency between the `compareTo` method of the `Comparable` interface and the `equals` method from the `Object` class.
+**Objective**: Learn basic operations of the `ArrayList`, such as adding, removing, and accessing elements.
 
-**Background**: It is strongly recommended (though not strictly required) that `(x.compareTo(y)==0) == (x.equals(y))`.
-Failure to adhere to this condition may cause unpredictable behavior when such objects are used in Java collections.
+**Task**:
+
+- Create an `ArrayList` of integers.
+- Add several integers to the list.
+- Remove specific integers from the list using index and object removal methods.
+- Access various elements in the list and print them.
+
+**Expected Output**: Demonstrate the current state of the list after each operation, showing successful addition, removal, and access of elements.
+
+---
+
+## Exercise 4: Implementing a Dynamic Array
+
+**Objective**: Understand how to use `ArrayList` to simulate a dynamic array that can expand based on runtime decisions.
+
+**Task**:
+
+- Create an `ArrayList` to store strings.
+- Simulate receiving an unknown number of string inputs from a user until "stop" is entered.
+- Store each input in the `ArrayList` and then print the entire list once "stop" is entered.
+
+**Expected Output**: Output all user inputs stored in the `ArrayList` after the user stops entering data.
+
+---
+
+## Exercise 5: Merging and Deduplicating ArrayLists
+
+**Objective**: Learn to merge two `ArrayLists` and remove duplicate items effectively.
+
+**Task**:
+
+- Create two `ArrayLists` of strings, each initialized with some predefined values, including some duplicates across the lists.
+- Merge the two lists into a new list that contains only unique elements, preserving the order.
+- Use a `HashSet` or `LinkedHashSet` to help with deduplication if necessary.
+
+**Expected Output**: A single merged `ArrayList` without duplicates, printed to the console.
+
+---
+
+## Exercise 6: `ArrayList` as a Stack
+
+**Objective**: Emulate stack behavior using an `ArrayList` to understand how it can be adapted for different data structure behaviors.
 
 **Task**:
 
-Create a class `Product` that implements the `Comparable` interface.
-A `Product` object has two properties:
-- `String productId`
-- `double price`
+- Use an `ArrayList` to implement a basic stack with operations: push, pop, and peek.
+- Ensure your implementation handles underflow (popping from an empty stack) gracefully.
+- Push a series of integers onto the stack, then pop several items, and peek at the top item, printing the results at each step.
 
-The `compareTo` method should sort products based on their price in ascending order.
+**Expected Output**: Show the contents of the stack after each operation and the result of peeking or popping items.
+
+---
 
-- Override the `equals` method in the `Product` class to ensure it is consistent with the `compareTo` method (i.e., two `Product` objects are equal if their `productId` is the same).
-- In your `main` method, create a `TreeSet` of `Product` objects and attempt to add duplicate products based on the `productId` to understand how the `equals` method is used in collection operations.
-- Iterate over the `TreeSet` and print out the details of each product to observe the effect of a consistent `equals` method.
+## Exercise 7: Random Access vs. Iterative Access in `ArrayList`
+
+**Objective**: Compare the performance of random access and sequential iterative access in an `ArrayList`.
+
+**Task**:
 
-> **Why `TreeSet` instead of `HashSet`?**
-> 
-> The `HashSet` does not maintain elements in sorted order; it's a collection designed for fast access and uniqueness checks without regard to the order of elements.
-> The sorting behavior you're expecting (i.e., seeing `Product` instances in a particular order based on their `productId` or `price`) won't be achieved with a `HashSet`.
-> 
-> `TreeSet` is a sorted collection that uses the natural ordering of its elements (defined by the `Comparable` implementation) or a `Comparator` provided at set creation time.
+- Fill an `ArrayList` with a large number of integers.
+- Measure and compare the time taken to access all elements randomly versus accessing them sequentially.
+- Use `System.nanoTime()` to measure elapsed time for each operation.
 
-**Expected Output**: The `TreeSet` should eliminate duplicate products based on the `productId`, demonstrating the importance of having a consistent `equals` method with `compareTo`.
+**Expected Output**: Print the time taken for random access and sequential access, highlighting the differences.

src/main/java/collections/arraylist/exercises/BasicArrayListOperations.java

@@ -0,0 +1,4 @@
+package collections.arraylist.exercises;
+
+public class BasicArrayListOperations {
+}

src/main/java/collections/arraylist/exercises/ImplementingDynamicArray.java

@@ -0,0 +1,31 @@
+package collections.arraylist.exercises;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class ImplementingDynamicArray {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        ArrayList<String> inputs = new ArrayList<>();
+
+        System.out.println("Enter strings to store in the dynamic array. Type 'stop' to finish.");
+
+        while (true) {
+            String input = scanner.nextLine();
+            if ("stop".equalsIgnoreCase(input)) {
+                break; // Exit the loop if user enters "stop"
+            }
+            inputs.add(input);
+        }
+
+        scanner.close(); // Close the scanner
+
+        // Print all stored inputs
+        System.out.println("You entered the following strings:");
+        for (String str : inputs) {
+            System.out.println(str);
+        }
+    }
+
+}

src/main/java/collections/arraylist/exercises/MergingAndDeduplicatingArrayLists.java

@@ -0,0 +1,28 @@
+package collections.arraylist.exercises;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+public class MergingAndDeduplicatingArrayLists {
+
+    public static void main(String[] args) {
+        // Create two ArrayLists with some predefined values and duplicates across the lists
+        List<String> list1 = new ArrayList<>(List.of("apple", "banana", "cherry"));
+        List<String> list2 = new ArrayList<>(List.of("banana", "dragonfruit", "apple", "elderberry"));
+
+        // Merge the two lists into a new list
+        List<String> mergedList = new ArrayList<>(list1);
+        mergedList.addAll(list2);
+
+        // Use a LinkedHashSet to remove duplicates and preserve order
+        Set<String> set = new LinkedHashSet<>(mergedList);
+        List<String> deduplicatedList = new ArrayList<>(set);
+
+        // Print the deduplicated list
+        System.out.println("Merged and Deduplicated List:");
+        deduplicatedList.forEach(System.out::println);
+    }
+
+}

src/main/java/collections/arraylist/exercises/RandomAccessVsIterativeAccess.java

@@ -0,0 +1,48 @@
+package collections.arraylist.exercises;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class RandomAccessVsIterativeAccess {
+
+    public static void main(String[] args) {
+        final int SIZE = 100000; // Number of integers to be added to the ArrayList
+        List<Integer> numbers = new ArrayList<>(SIZE);
+        Random random = new Random();
+
+        // Filling the ArrayList with random integers
+        for (int i = 0; i < SIZE; i++) {
+            numbers.add(random.nextInt());
+        }
+
+        // Sequential access
+        long startTimeSequential = System.nanoTime();
+        for (int i = 0; i < SIZE; i++) {
+            int num = numbers.get(i); // Sequential access
+        }
+        long endTimeSequential = System.nanoTime();
+        long durationSequential = endTimeSequential - startTimeSequential;
+
+        // Random access
+        long startTimeRandom = System.nanoTime();
+        for (int i = 0; i < SIZE; i++) {
+            int index = random.nextInt(SIZE); // Generate a random index to access
+            int num = numbers.get(index); // Random access
+        }
+        long endTimeRandom = System.nanoTime();
+        long durationRandom = endTimeRandom - startTimeRandom;
+
+        // Output the results
+        System.out.println("Time taken for sequential access: " + durationSequential + " nanoseconds");
+        System.out.println("Time taken for random access: " + durationRandom + " nanoseconds");
+
+        // Highlighting the difference
+        if (durationSequential < durationRandom) {
+            System.out.println("Sequential access was faster by " + (durationRandom - durationSequential) + " nanoseconds.");
+        } else {
+            System.out.println("Random access was faster by " + (durationSequential - durationRandom) + " nanoseconds.");
+        }
+    }
+
+}

src/main/java/collections/arraylist/exercises/SimplifiedStackUsingArrayList.java

@@ -0,0 +1,63 @@
+package collections.arraylist.exercises;
+
+public class SimplifiedStackUsingArrayList<T> {
+
+    private Object[] array; // Using Object array to store any type of items
+    private int size = 0; // Current number of items in the stack
+    private int capacity; // Maximum capacity of the stack
+
+    public SimplifiedStackUsingArrayList(int capacity) {
+        this.capacity = capacity;
+        array = new Object[capacity];
+    }
+
+    public void push(T item) {
+        if (size == capacity) {
+            throw new StackOverflowError("Stack is full");
+        }
+        array[size++] = item;
+    }
+
+    @SuppressWarnings("unchecked")
+    public T pop() {
+        if (size == 0) {
+            throw new IllegalStateException("Stack is empty");
+        }
+        return (T) array[--size];
+    }
+
+    @SuppressWarnings("unchecked")
+    public T peek() {
+        if (size == 0) {
+            throw new IllegalStateException("Stack is empty");
+        }
+        return (T) array[size - 1];
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public static void main(String[] args) {
+        SimplifiedStackUsingArrayList<Integer> stack = new SimplifiedStackUsingArrayList<>(10);
+
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+
+        System.out.println("Top element (peek): " + stack.peek()); // Should print 3
+        System.out.println("Pop element: " + stack.pop()); // Should remove and print 3
+        System.out.println("Next top element (peek): " + stack.peek()); // Should print 2
+
+        // Demonstrate pushing beyond capacity
+        try {
+            for (int i = 0; i < 10; i++) {
+                stack.push(i);
+            }
+        } catch (StackOverflowError e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+}
+

src/main/java/collections/arraylist/Product.java renamed to src/main/java/collections/treeset/ConsistencyWithEqualsMethod.java

@@ -1,10 +1,13 @@
-package collections.arraylist;
+package collections.treeset;
+
+import lombok.Getter;
 
 import java.util.Objects;
 import java.util.Set;
 import java.util.TreeSet;
 
-public class Product implements Comparable<Product> {
+@Getter
+class Product implements Comparable<Product> {
 
     private final String productId;
     private final double price;
@@ -21,8 +24,8 @@ public int compareTo(Product product) {
 
     @Override
     public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (obj == null || getClass() != obj.getClass()) return false;
+        if (this == obj) { return true; }
+        if (obj == null || getClass() != obj.getClass()) { return false; }
         Product product = (Product) obj;
         return Objects.equals(this.productId, product.productId);
     }
@@ -32,9 +35,14 @@ public int hashCode() {
         return Objects.hash(this.productId, this.price);
     }
 
+}
+
+public class ConsistencyWithEqualsMethod {
+
     public static void main(String[] args) {
         Product x = new Product("1234", 123.45);
         Product y = new Product("1234", 123.45);
+        if ((x.compareTo(y) == 0) != (x.equals(y))) { throw new AssertionError("Condition should evaluate to true"); }
         System.out.println((x.compareTo(y) == 0) == (x.equals(y)));
 
         TreeSet<Product> products = new TreeSet<>(Set.of(
@@ -43,7 +51,7 @@ public static void main(String[] args) {
             new Product("2136", 123.45),
             new Product("2136", 321.45)
         ));
-        products.forEach(product -> System.out.println("Product ID: " + product.productId + "; Price: " + product.price));
+        products.forEach(product -> System.out.println("Product ID: " + product.getProductId() + "; Price: " + product.getPrice()));
     }
 
 }