Java ArrayList Exercises: 30 Coding Problems with Solutions

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> languages = new ArrayList<>();
        languages.add("Java");
        languages.add("Python");
        languages.add("JavaScript");
        languages.add("C++");
        languages.add("Go");

        System.out.println("Languages = " + languages);
    }
}Code language: Java (java)

Explanation:

• new ArrayList<>(): Creates an empty, resizable list that can grow as elements are added, unlike a fixed-size array.
• languages.add("Java"): Appends each element to the end of the list, one call per language.
• System.out.println("Languages = " + languages): Relies on ArrayList‘s built-in toString() method, which automatically formats the list as comma-separated values inside square brackets.
• Alternative: You could use List.of("Java", "Python", ...) combined with new ArrayList<>(...) to initialize the list in a single line, though it creates an intermediate immutable list first.

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        System.out.print("Standard for: ");
        for (int i = 0; i < fruits.size(); i++) {
            System.out.print(fruits.get(i) + " ");
        }
        System.out.println();
        System.out.print("For-each: ");
        for (String fruit : fruits) {
            System.out.print(fruit + " ");
        }
        System.out.println();
        System.out.print("Iterator: ");
        Iterator<String> it = fruits.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
    }
}Code language: Java (java)

Explanation:

• for (int i = 0; i < fruits.size(); i++): Uses an index to access elements directly with get(i), giving full control over the position being read.
• for (String fruit : fruits): Iterates over each element automatically without managing an index, making the code more concise for simple traversal.
• Iterator<String> it = fruits.iterator(): Creates an explicit iterator object, useful when you need to remove elements safely during iteration with it.remove().
• Alternative: You could use fruits.forEach(fruit -> System.out.print(fruit + " ")) with a lambda expression for a fourth, more modern iteration style.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(20);
        numbers.add(30);
        numbers.add(40);

        numbers.add(0, 10);

        System.out.println("Numbers = " + numbers);
    }
}Code language: Java (java)

Explanation:

• numbers.add(20): Appends elements to the end of the list in the order they are added.
• numbers.add(0, 10): Uses the two-argument overload of add() to insert 10 at index 0, pushing all other elements one position later.
• Automatic resizing: The ArrayList internally shifts elements and grows its backing array as needed, so you don't have to manage array indices manually.
• Alternative: You could rebuild the list with the new element first by creating a new ArrayList and adding elements in the desired order, though the indexed add() is far simpler for a single insertion.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");

        int index = 3;
        try {
            System.out.println("Element at index " + index + " = " + colors.get(index));
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Index " + index + " is out of bounds for this list.");
        }
    }
}Code language: Java (java)

Explanation:

• colors.get(index): Attempts to retrieve the element at the given position, throwing an exception if the index is invalid.
• catch (IndexOutOfBoundsException e): Catches the specific exception ArrayList throws when an index is negative or greater than or equal to the list's size.
• Graceful error handling: Prevents the program from terminating abruptly, instead giving the user a clear explanation of what went wrong.
• Alternative: You could check index >= 0 && index < colors.size() before calling get(), avoiding the exception entirely, though try-catch is useful when the check itself is easy to forget.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");

        int index = colors.indexOf("Red");
        colors.set(index, "Crimson");

        System.out.println("Updated Colors = " + colors);
    }
}Code language: Java (java)

Explanation:

• colors.indexOf("Red"): Locates the position of the element to replace without hardcoding an index number.
• colors.set(index, "Crimson"): Replaces the element at the found index with the new value, leaving the size of the list unchanged.
• set() versus add(): set() overwrites an existing position, while add(index, element) would instead insert a new element and shift everything else.
• Alternative: You could loop through the list checking each element with equals() and replace it manually, but set() combined with indexOf() is more direct.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Double> values = new ArrayList<>();
        values.add(1.5);
        values.add(2.5);
        values.add(3.5);
        values.add(4.5);

        values.remove(2);

        System.out.println("Values = " + values);
    }
}Code language: Java (java)

Explanation:

• values.remove(2): Uses the int overload of remove(), which removes the element at index 2 (the third element) rather than searching for a matching value.
• Element shifting: After removal, elements that came after index 2 move one position earlier, keeping the list contiguous.
• int versus Integer overload: remove(int index) removes by position, while remove(Object o) removes by matching value, which is an easy source of bugs with Integer lists specifically.
• Alternative: You could use values.remove(Double.valueOf(3.5)) to remove by value instead of position, though it requires knowing the exact value in advance.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> items = new ArrayList<>();
        items.add("Pen");
        items.add("Notebook");
        items.add("Eraser");

        String target = "Notebook";
        if (items.contains(target)) {
            System.out.println("Found \"" + target + "\" at index " + items.indexOf(target) + ".");
        } else {
            System.out.println("Not Found");
        }
    }
}Code language: Java (java)

Explanation:

• items.contains(target): Checks whether the target string exists anywhere in the list, returning a simple boolean.
• items.indexOf(target): Returns the position of the first matching element, only called after confirming the element exists.
• String comparison: Both methods use equals() internally, correctly comparing the contents of Strings rather than their memory references.
• Alternative: You could skip the contains() check and rely solely on indexOf(), treating a return value of -1 as "not found," which avoids scanning the list twice.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        System.out.println("Before clear: Is Empty = " + numbers.isEmpty());

        numbers.clear();

        System.out.println("After clear: Is Empty = " + numbers.isEmpty());
    }
}Code language: Java (java)

Explanation:

• numbers.isEmpty(): Returns true only when the list contains zero elements, providing a cleaner check than comparing size() to 0.
• numbers.clear(): Removes every element from the list in a single call, resetting its size to zero without creating a new list object.
• Before and after comparison: Demonstrates that clear() actually empties the existing list rather than just reassigning the variable to a new empty list.
• Alternative: You could reassign numbers = new ArrayList<>() to achieve a similarly empty list, but that creates a new object instead of clearing the existing one, which matters if other references point to the original list.

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(3);
        numbers.add(8);
        numbers.add(1);
        numbers.add(9);

        Collections.sort(numbers);
        System.out.println("Ascending = " + numbers);

        Collections.sort(numbers, Collections.reverseOrder());
        System.out.println("Descending = " + numbers);
    }
}Code language: Java (java)

Explanation:

• Collections.sort(numbers): Sorts the list in place using the natural ordering of Integer values, which is ascending numerical order.
• Collections.reverseOrder(): Provides a Comparator that reverses the natural ordering, which Collections.sort() then uses to sort in descending order.
• In-place sorting: Both calls modify the same list object directly rather than returning a new sorted list.
• Alternative: You could use numbers.sort(Comparator.reverseOrder()) directly on the list instance instead of passing it through Collections.sort(), since List gained a sort() method in Java 8.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> original = new ArrayList<>();
        original.add("A");
        original.add("B");
        original.add("C");

        ArrayList<String> copy = new ArrayList<>(original);

        System.out.println("Copy = " + copy);
    }
}Code language: Java (java)

Explanation:

• new ArrayList<>(original): Uses the copy constructor, which creates a new list containing all the same elements as the original at the time of copying.
• Independent lists: Since the constructor copies element references into a new backing array, modifying copy afterward (like adding or removing elements) does not affect original, and vice versa.
• Shallow copy note: While the list itself is independent, if the elements were mutable objects rather than immutable Strings, both lists would still reference the same underlying objects.
• Alternative: You could use copy.addAll(original) on an already-created empty list to achieve the same result, which is useful when the destination list already exists.

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Before = " + numbers);
        Collections.shuffle(numbers);
        System.out.println("Shuffled = " + numbers);
    }
}Code language: Java (java)

Explanation:

• Collections.shuffle(numbers): Randomly permutes the elements of the list in place using a default source of randomness.
• Non-deterministic output: Since shuffle() uses an internal Random instance seeded by the current time by default, the resulting order differs on each program run.
• In-place modification: The original list object is reordered directly rather than a new shuffled list being created.
• Alternative: You could pass a seeded Random object, like Collections.shuffle(numbers, new Random(42)), to get a reproducible shuffle order, which is useful for testing.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        int left = 0;
        int right = numbers.size() - 1;
        while (left < right) {
            int temp = numbers.get(left);
            numbers.set(left, numbers.get(right));
            numbers.set(right, temp);
            left++;
            right--;
        }
        System.out.println("Reversed = " + numbers);
    }
}Code language: Java (java)

Explanation:

• left and right: Two pointers that start at opposite ends of the list and move toward each other.
• numbers.set(left, numbers.get(right)): Uses get() and set() together to swap the values at the two pointer positions without a built-in swap method.
• left++ / right--: Advances both pointers toward the middle after each swap, ensuring the loop eventually terminates.
• Alternative: You could build a brand new ArrayList by iterating through the original from last to first and adding each element, though the two-pointer swap avoids creating extra objects.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(40);
        numbers.add(50);
        numbers.add(60);
        numbers.add(70);
        numbers.add(80);

        List<Integer> sublist = new ArrayList<>(numbers.subList(2, 7));

        System.out.println("Sublist = " + sublist);
    }
}Code language: Java (java)

Explanation:

• numbers.subList(2, 7): Extracts elements from index 2 up to, but not including, index 7, capturing indices 2 through 6.
• new ArrayList<>(...): Wraps the returned view in a new list so the sublist is independent, since subList() by itself returns a live view backed by the original list.
• Live view caveat: Without the copy constructor, structural changes to the original list (like adding or removing elements) could throw a ConcurrentModificationException on the view.
• Alternative: You could manually loop from index 2 to 6 and add each element to a new ArrayList, which avoids the live-view behavior entirely but requires more code.

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> items = new ArrayList<>();
        items.add("A");
        items.add("B");
        items.add("C");
        items.add("D");

        Collections.swap(items, 1, 3);

        System.out.println("Swapped = " + items);
    }
}Code language: Java (java)

Explanation:

• Collections.swap(items, 1, 3): Swaps the elements currently at index 1 and index 3, handling the exchange internally without needing a manual temporary variable.
• In-place operation: The same list object is modified directly, with no new list created.
• Index validity: Both indices must fall within the current bounds of the list, or an IndexOutOfBoundsException will be thrown.
• Alternative: You could implement the swap manually using get() and set() with a temporary variable, which is exactly what Collections.swap() does internally.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        listA.add("Apple");
        listA.add("Banana");

        ArrayList<String> listB = new ArrayList<>();
        listB.add("Cherry");
        listB.add("Date");

        ArrayList<String> combined = new ArrayList<>();
        combined.addAll(listA);
        combined.addAll(listB);

        System.out.println("Combined = " + combined);
    }
}Code language: Java (java)

Explanation:

• combined.addAll(listA): Appends every element from listA to the end of combined, preserving their original order.
• combined.addAll(listB): Appends every element from listB immediately after listA's elements.
• New destination list: Using a separate combined list keeps both listA and listB unmodified, unlike calling listA.addAll(listB) directly.
• Alternative: You could use Stream.concat(listA.stream(), listB.stream()).collect(Collectors.toList()) for a more functional-style approach to merging.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> original = new ArrayList<>();
        original.add("X");
        original.add("Y");
        original.add("Z");

        @SuppressWarnings("unchecked")
        ArrayList<String> clone = (ArrayList<String>) original.clone();

        System.out.println("Clone = " + clone);
    }
}Code language: Java (java)

Explanation:

• original.clone(): Creates a shallow copy of the ArrayList, meaning a new list object is created but its elements are not individually duplicated.
• (ArrayList<String>) original.clone(): Casts the returned Object back to the expected generic type, since clone() has an untyped return signature.
• @SuppressWarnings("unchecked"): Suppresses the compiler warning that results from this necessary but inherently unchecked cast.
• Alternative: You could use the copy constructor new ArrayList<>(original) instead of clone(), which is generally preferred in modern Java code since it avoids the unchecked cast entirely.

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] array = {"Red", "Green", "Blue"};
        ArrayList<String> list = new ArrayList<>(Arrays.asList(array));

        System.out.println("List = " + list);
    }
}Code language: Java (java)

Explanation:

• Arrays.asList(array): Wraps the existing array in a List view backed directly by the array, without copying its elements.
• new ArrayList<>(...): Copies the elements from that fixed-size view into a brand new, fully resizable ArrayList.
• Fixed-size limitation: Calling add() or remove() directly on the result of Arrays.asList() throws an UnsupportedOperationException, which is why wrapping it in an ArrayList constructor matters.
• Alternative: You could loop through the array manually and call add() for each element, though Arrays.asList() combined with the constructor is far more concise.

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);

        Integer[] array = numbers.toArray(new Integer[0]);

        System.out.println("Array = " + Arrays.toString(array));
    }
}Code language: Java (java)

Explanation:

• numbers.toArray(new Integer[0]): Converts the list's elements into an Integer[] array, using the provided zero-length array purely to specify the desired return type.
• Zero-length array argument: If the array passed in is too small, toArray() allocates a new array of the correct size internally, so a zero-length array is an efficient and idiomatic choice.
• Arrays.toString(array): Provides a readable, comma-separated representation of the array's contents, since arrays don't have a useful default toString() like ArrayList does.
• Alternative: You could call numbers.toArray() without arguments to get a plain Object[], but that loses type information and requires casting each element when accessed.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(-3);
        numbers.add(8);
        numbers.add(-1);
        numbers.add(0);
        numbers.add(-7);
        for (int i = 0; i < numbers.size(); i++) {
            if (numbers.get(i) < 0) {
                numbers.set(i, 0);
            }
        }
        System.out.println("Result = " + numbers);
    }
}Code language: Java (java)

Explanation:

• for (int i = 0; i < numbers.size(); i++): Uses an index-based loop so each element can be checked and replaced at its exact position.
• numbers.get(i) < 0: Checks whether the current element is negative before deciding to replace it.
• numbers.set(i, 0): Overwrites only the negative elements in place, leaving zero and positive values unchanged.
• Alternative: You could use numbers.replaceAll(n -> n < 0 ? 0 : n) with a lambda expression for a more concise, functional-style solution.

import java.util.ArrayList;

public class Main {
    public static void keepEvens(ArrayList<Integer> numbers) {
        numbers.removeIf(n -> n % 2 != 0);
    }

    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        numbers.add(6);
        numbers.add(7);
        numbers.add(8);

        keepEvens(numbers);
        System.out.println("Result = " + numbers);
    }
}Code language: Java (java)

Explanation:

• numbers.removeIf(n -> n % 2 != 0): Removes every element for which the lambda condition evaluates to true, in this case any number with a non-zero remainder when divided by 2.
• n % 2 != 0: Identifies odd numbers, since even numbers always produce a remainder of 0 when divided by 2.
• Safe removal during iteration: removeIf() internally handles the iteration and removal process safely, avoiding the ConcurrentModificationException that manual removal during a for-each loop would cause.
• Alternative: You could build a brand new list containing only the even numbers using a stream, like numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList()), which avoids mutating the original list.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>(20);
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        numbers.trimToSize();

        System.out.println("Size = " + numbers.size());
    }
}Code language: Java (java)

Explanation:

• new ArrayList<>(20): Creates a list with an initial backing array capacity of 20 elements, even though it starts out empty.
• numbers.trimToSize(): Resizes the internal backing array down to match the current number of elements, releasing the unused reserved capacity back to the JVM.
• Invisible via public API: There's no public method to directly observe an ArrayList's capacity, so this optimization matters for memory usage internally even though size() still reports 3 both before and after.
• Alternative: You could avoid over-allocating capacity in the first place by using the no-argument new ArrayList<>() constructor, which starts with a small default capacity and grows only as needed.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> listA = new ArrayList<>();
        listA.add(1);
        listA.add(2);
        listA.add(3);

        ArrayList<Integer> listB = new ArrayList<>();
        listB.add(1);
        listB.add(2);
        listB.add(3);

        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(3);
        listC.add(2);
        listC.add(1);

        System.out.println("listA equals listB = " + listA.equals(listB));
        System.out.println("listA equals listC = " + listA.equals(listC));
    }
}Code language: Java (java)

Explanation:

• listA.equals(listB): Returns true because both lists contain the same elements in the same order, which is exactly what ArrayList's equals() checks for.
• listA.equals(listC): Returns false because, despite containing the same elements, listC has them in a different order.
• Order-sensitive comparison: Unlike a Set, an ArrayList's equality depends on element order, reflecting its nature as a sequential, indexed collection.
• Alternative: You could manually loop through both lists comparing elements at each index, but equals() already implements this logic correctly and concisely.

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(4);
        numbers.add(4);
        numbers.add(5);

        Set<Integer> uniqueSet = new LinkedHashSet<>(numbers);
        ArrayList<Integer> unique = new ArrayList<>(uniqueSet);

        System.out.println("Unique = " + unique);
    }
}Code language: Java (java)

Explanation:

• new LinkedHashSet<>(numbers): Copies the list's elements into a set, automatically discarding duplicates while preserving the original insertion order.
• new ArrayList<>(uniqueSet): Converts the deduplicated set back into a list so the result supports indexed access and the usual ArrayList methods again.
• LinkedHashSet versus HashSet: A plain HashSet would also remove duplicates but wouldn't guarantee the original order is preserved, which is why LinkedHashSet is used here.
• Alternative: You could use a plain HashSet if the resulting order doesn't matter for your use case, which has marginally less overhead than LinkedHashSet.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(4);
        numbers.add(4);
        numbers.add(5);
        for (int i = 0; i < numbers.size(); i++) {
            for (int j = numbers.size() - 1; j > i; j--) {
                if (numbers.get(j).equals(numbers.get(i))) {
                    numbers.remove(j);
                }
            }
        }
        System.out.println("Unique = " + numbers);
    }
}Code language: Java (java)

Explanation:

• Outer loop (index i): Treats each element in turn as the "reference" value to compare against everything after it.
• Inner loop (index j, counting down): Scans from the end of the list back toward i + 1, checking for any later duplicate of the reference value.
• numbers.remove(j): Removes a confirmed duplicate immediately; counting the inner loop downward ensures removing an element doesn't disturb the indices still left to check.
• Alternative: You could achieve a similar in-place result with a single forward pass that shifts elements manually, but the backward-scanning nested loop is simpler to reason about correctly.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> listA = new ArrayList<>();
        listA.add(1);
        listA.add(2);
        listA.add(3);
        listA.add(4);
        listA.add(5);

        ArrayList<Integer> listB = new ArrayList<>();
        listB.add(3);
        listB.add(4);
        listB.add(5);
        listB.add(6);
        listB.add(7);

        ArrayList<Integer> common = new ArrayList<>();
        for (Integer value : listA) {
            if (listB.contains(value)) {
                common.add(value);
            }
        }

        System.out.println("Common = " + common);
    }
}Code language: Java (java)

Explanation:

• for (Integer value : listA): Iterates through every element of the first list to check it against the second.
• listB.contains(value): Determines whether the current element from listA also appears somewhere in listB.
• common.add(value): Collects every element confirmed to exist in both lists into the results list.
• Alternative: You could use retainAll() on a copy of listA, like new ArrayList<>(listA).retainAll(listB), which achieves the same result with a single built-in method call.

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> items = new ArrayList<>();
        items.add("apple");
        items.add("banana");
        items.add("apple");
        items.add("orange");
        items.add("banana");
        items.add("apple");

        Map<String, Integer> frequency = new LinkedHashMap<>();
        for (String item : items) {
            frequency.put(item, frequency.getOrDefault(item, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : frequency.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}Code language: Java (java)

Explanation:

• Map<String, Integer> frequency: Associates each unique element with a running count of how many times it has appeared.
• frequency.getOrDefault(item, 0) + 1: Retrieves the current count for an element, defaulting to zero if it's the first occurrence, then increments it.
• LinkedHashMap: Preserves the order in which elements were first encountered, so the printed output follows a predictable sequence.
• Alternative: You could use frequency.merge(item, 1, Integer::sum) instead of getOrDefault() combined with put(), which condenses the increment logic into a single method call.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> words = new ArrayList<>();
        words.add("cat");
        words.add("elephant");
        words.add("dog");
        words.add("hippopotamus");
        words.add("ant");
        words.add("kangaroo");
        ArrayList<String> shortWords = new ArrayList<>();
        ArrayList<String> longWords = new ArrayList<>();
        for (String word : words) {
            if (word.length() < 5) {
                shortWords.add(word);
            } else {
                longWords.add(word);
            }
        }
        System.out.println("Short = " + shortWords);
        System.out.println("Long = " + longWords);
    }
}Code language: Java (java)

Explanation:

• word.length() < 5: Determines which category a word belongs to based on its character count.
• shortWords.add(word) / longWords.add(word): Places each word into the appropriate list without modifying the original words list.
• Single pass: The original list is only iterated once, with each element classified and placed immediately.
• Alternative: You could use streams with partitioningBy(), like words.stream().collect(Collectors.partitioningBy(w -> w.length() < 5)), which returns both groups in a single Map<Boolean, List<String>>.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> listA = new ArrayList<>();
        listA.add(1);
        listA.add(3);
        listA.add(5);
        listA.add(7);
        ArrayList<Integer> listB = new ArrayList<>();
        listB.add(2);
        listB.add(4);
        listB.add(6);
        listB.add(8);
        ArrayList<Integer> merged = new ArrayList<>();
        int i = 0;
        int j = 0;
        while (i < listA.size() && j < listB.size()) {
            if (listA.get(i) <= listB.get(j)) {
                merged.add(listA.get(i));
                i++;
            } else {
                merged.add(listB.get(j));
                j++;
            }
        }
        while (i < listA.size()) {
            merged.add(listA.get(i));
            i++;
        }
        while (j < listB.size()) {
            merged.add(listB.get(j));
            j++;
        }
        System.out.println("Merged = " + merged);
    }
}Code language: Java (java)

Explanation:

• while (i < listA.size() && j < listB.size()): Continues comparing elements from both lists as long as both still have unprocessed elements remaining.
• listA.get(i) <= listB.get(j): Determines which of the two current elements is smaller, adding it to the merged result and advancing only that list's pointer.
• Trailing while loops: Once one list runs out, the remaining elements of the other list are already sorted, so they can be appended directly without further comparison.
• Alternative: You could combine both lists and call Collections.sort() on the result, but that ignores the fact that both inputs are already sorted and does unnecessary extra work.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(7);
        numbers.add(5);
        int target = 12;
        int start = 0;
        int sum = 0;
        ArrayList<Integer> result = new ArrayList<>();
        for (int end = 0; end < numbers.size(); end++) {
            sum += numbers.get(end);
            while (sum > target && start <= end) {
                sum -= numbers.get(start);
                start++;
            }
            if (sum == target) {
                result = new ArrayList<>(numbers.subList(start, end + 1));
                break;
            }
        }
        System.out.println("Sublist Sum Found = " + result);
    }
}Code language: Java (java)

Explanation:

• sum += numbers.get(end): Expands the window by adding the next element to the running sum.
• while (sum > target && start <= end): Shrinks the window from the left whenever the running sum overshoots the target, since all values are positive and removing elements only decreases the sum.
• sum == target: Confirms the current window's elements add exactly to the target, at which point the matching sublist is captured using subList().
• Alternative: You could use a brute-force approach checking every possible start and end combination, but the sliding window technique runs in linear time and only works correctly here because all numbers are positive.

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Student {
    private int id;
    private String name;
    private double gpa;

    public Student(int id, String name, double gpa) {
        this.id = id;
        this.name = name;
        this.gpa = gpa;
    }

    public String getName() {
        return name;
    }

    public double getGpa() {
        return gpa;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1, "Alice", 3.8));
        students.add(new Student(2, "Bob", 3.2));
        students.add(new Student(3, "Charlie", 3.9));

        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student a, Student b) {
                return Double.compare(b.getGpa(), a.getGpa());
            }
        });

        for (Student student : students) {
            System.out.println(student.getName() + " - GPA: " + student.getGpa());
        }
    }
}Code language: Java (java)

Explanation:

• Comparator<Student>: Defines custom comparison logic for Student objects, since they don't have a natural ordering of their own.
• Double.compare(b.getGpa(), a.getGpa()): Compares the two gpa values in reverse order (b before a), which produces a descending sort instead of the default ascending one.
• Collections.sort(students, comparator): Applies the custom comparator to sort the list in place according to the defined logic.
• Alternative: You could use a lambda expression instead of an anonymous Comparator class, like students.sort((a, b) -> Double.compare(b.getGpa(), a.getGpa())), or use Comparator.comparingDouble(Student::getGpa).reversed() for a more fluent, readable style.