Java SE 25: Comparable and List Implementations

Review natural ordering, ArrayList and LinkedList tradeoffs, legacy Vector synchronization, RandomAccess, and list traversal in Java SE 25.

1. What is the purpose of Comparable?

   Answer: Comparable<T> lets a class define its natural ordering through compareTo(T). A negative result means less than, zero means equal in the ordering, and a positive result means greater than. Natural-order sorting and sorted collections can use that rule.

   For value types, make comparison equality agree with equals when possible. A record with both id and name components should not compare only id unless you deliberately document the inconsistency. The example compares both components.

   import java.util.ArrayList;
   import java.util.Comparator;
   import java.util.List;
   import java.util.Objects;
   
   public class EmployeeOrdering {
       record Employee(int id, String name) implements Comparable<Employee> {
           Employee { Objects.requireNonNull(name); }
           @Override public int compareTo(Employee other) {
               int byId = Integer.compare(id, other.id);
               return byId != 0 ? byId : name.compareTo(other.name);
           }
       }
       public static void main(String[] args) {
           List<Employee> staff = new ArrayList<>(List.of(
               new Employee(2, "Amy"), new Employee(1, "Zoe")));
           staff.sort(null);
           System.out.println(staff.getFirst().name());
           staff.sort(Comparator.comparing(Employee::name)
               .thenComparingInt(Employee::id));
           System.out.println(staff.getFirst().name());
       }
   }
   

2. Why do some collections not preserve insertion order?

   Answer: Their contract prioritizes another organization. HashSet provides hash-based membership without an order promise; TreeSet maintains comparison order. LinkedHashSet normally preserves insertion order, while List provides positions the caller can edit. Choose the documented semantics instead of relying on the order seen in one test run.

3. What distinguishes a List from other collections?

   Answer: List provides positional access and normally permits duplicate elements. Methods include get, set, indexed add, and indexed remove. A Set controls membership without list indices; a Queue focuses on its head and processing discipline. In Java SE 25, List also extends SequencedCollection.

4. What determines order in common List implementations?

   Answer: Index positions determine encounter order in ArrayList, LinkedList, and Vector. Appending, inserting, removing, replacing, and sorting determine what occupies those positions. These classes share List semantics even though their storage strategies and synchronization differ.

5. What is ArrayList for?

   Answer: It is a resizable-array List for indexed storage and traversal. It supports generics, null elements, duplicates, and constant-time get/set operations. Appending is amortized constant time; an individual growth operation can require copying the backing array. Inserting or removing near the front shifts elements.

6. When should you choose ArrayList over LinkedList?

   Answer: ArrayList suits frequent indexed access and often offers efficient traversal with less per-element overhead. LinkedList must traverse nodes to reach an arbitrary index. A linked-list insertion is constant time only after the relevant position is already known, such as through a positioned ListIterator.

   For a queue or stack, also consider ArrayDeque. Measure representative workloads when performance determines the choice; the claim that LinkedList is always better for frequent insertions ignores the cost of finding their positions.

7. Which collection classes are important legacy types?

   Answer: Vector and Hashtable predate the Java Collections Framework and were later integrated into it. Stack is a legacy Vector subclass. They remain available for compatibility. ArrayList, HashMap, Deque implementations, and concurrency-oriented collections provide alternatives with more suitable contracts for many new designs.

8. How do Vector and ArrayList differ?

   Answer: Both implement resizable lists, but Vector synchronizes many individual operations and ArrayList does not. Several individually synchronized calls are not automatically one atomic action. For example, a size check followed by get can race with a removal unless the complete sequence is coordinated.

   Collections.synchronizedList requires its documented locking discipline, including during iteration. CopyOnWriteArrayList offers snapshot traversal at a copying cost on mutation and suits some read-heavy workloads. Thread safety is a design requirement, not just a class-name substitution.

9. Which List classes implement RandomAccess?

   Answer: ArrayList and Vector do, and so does CopyOnWriteArrayList. RandomAccess is a marker interface indicating efficient indexed access; it does not mean random iteration order. LinkedList does not implement it. Generic algorithms can use the marker to choose indexed traversal versus iterator-based traversal.

10. How can you print all elements of an ArrayList?

    Answer: Use an enhanced for loop, list.forEach(System.out::println), or print the list itself. The first two put each element on its own line; printing the list produces its bracketed representation. Custom element types should provide readable toString output when that representation is useful.

    An index loop is also valid for ArrayList. Avoid applying repeated indexed get calls indiscriminately to LinkedList, where repeated traversal can make a full loop quadratic.

Java SE 25 references: Comparable, ArrayList, LinkedList, Vector, RandomAccess, CopyOnWriteArrayList.