List

🔍 What Is It?

List Interface

java.util.List extends Collection and adds:

• →get(int index) — access by position
• →set(int index, E element) — replace at position
• →add(int index, E element) — insert at position
• →remove(int index) — remove at position
• →indexOf(Object o) — find first occurrence
• →subList(int from, int to) — view of a portion
• →listIterator() — bidirectional iteration

Key Implementations:

• →ArrayList — resizable array; O(1) random access; O(n) insert/delete in middle
• →LinkedList — doubly-linked list; O(n) random access; O(1) insert/delete at known position; also implements Deque
• →Vector — legacy synchronized ArrayList; avoid in new code
• →CopyOnWriteArrayList — thread-safe; creates copy on every write; best for read-heavy concurrent access
• →List.of() — immutable list (Java 9+); throws UnsupportedOperationException on modification
• →Arrays.asList() — fixed-size list backed by array; allows set() but not add/remove

🎯 Why Do We Need It?

Lists solve ordered collection needs:

• →Ordered data — results from a database query, items in a shopping cart, steps in a workflow
• →Index access — pagination (get items 20-40), random sampling
• →Duplicates allowed — unlike Set, List allows the same element multiple times
• →Iteration order guaranteed — elements always come out in insertion order

In enterprise Java, List is the most commonly used collection type — most service methods return List<SomeEntity>.

🏗️ What Happens in Real Projects?

Common patterns in enterprise code:

// Service returns List
public List<Order> getOrdersByCustomer(String customerId) {
    return orderRepository.findByCustomerId(customerId);
}

// Immutable list for constants
private static final List<String> VALID_CURRENCIES = List.of("USD", "EUR", "GBP");

// Defensive copy to prevent external modification
public List<LineItem> getLineItems() {
    return Collections.unmodifiableList(lineItems);
}

// Sorting
orders.sort(Comparator.comparing(Order::getCreatedAt).reversed());

⚙️ How It Works

ArrayList Internals:

• →Backed by an Object[] array
• →Initial capacity: 10
• →When full, creates new array 1.5x the size and copies elements
• →This resize is O(n) but happens rarely — amortized O(1) add
• →Random access: O(1) — direct array index
• →Insert/delete in middle: O(n) — must shift elements

LinkedList Internals:

• →Each element is a Node with prev and next pointers
• →No array — no resizing
• →Random access: O(n) — must traverse from head
• →Insert/delete at known position: O(1) — just update pointers
• →Higher memory overhead: each node has two extra references

💻 Example

List Patterns in Enterprise Code — The List operations you use in every Java project.

// Creating lists
List<String> mutable = new ArrayList<>();          // empty, can add/remove
List<String> fromArray = new ArrayList<>(Arrays.asList("a", "b", "c"));
List<String> immutable = List.of("a", "b", "c");  // Java 9+, cannot modify
List<String> copy = new ArrayList<>(immutable);    // mutable copy of immutable

// Basic operations
mutable.add("hello");
mutable.add(0, "first");          // insert at index 0
mutable.set(1, "updated");        // replace at index 1
mutable.remove(0);                // remove by index
mutable.remove("hello");          // remove by value (first occurrence)
String item = mutable.get(0);     // O(1) for ArrayList
boolean has = mutable.contains("hello");
int idx = mutable.indexOf("hello");

// Bulk operations
mutable.addAll(List.of("x", "y", "z"));
mutable.removeAll(List.of("x", "y"));
mutable.retainAll(List.of("z", "hello"));  // keep only these

// Iteration
for (String s : mutable) { System.out.println(s); }
mutable.forEach(System.out::println);
mutable.stream().filter(s -> s.length() > 3).forEach(System.out::println);

// Sorting
List<Integer> numbers = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9));
Collections.sort(numbers);                          // natural order
numbers.sort(Comparator.reverseOrder());            // reverse
numbers.sort(Comparator.comparingInt(Math::abs));   // by absolute value

// Sublist (view — changes affect original!)
List<Integer> sub = numbers.subList(1, 4);  // elements 1, 2, 3 (not 4)

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits