Java's List interface is a cornerstone of the Collections Framework, providing ordered, index-based access to elements. With implementations like ArrayList and LinkedList, mastering list operations—from initialization to conversion—is crucial for effective Java development. This Q&A covers the most common tasks and pitfalls, helping you handle lists with confidence.

What are the key differences between ArrayList and LinkedList in Java?

ArrayList and LinkedList both implement the List interface but have distinct performance characteristics. ArrayList internally uses a dynamic array, offering fast random access (O(1) for get) and efficient iteration. However, insertions and deletions at arbitrary positions are slower (O(n)) because elements must be shifted. LinkedList uses a doubly-linked list, making insertions and deletions at both ends or known positions fast (O(1) once the node is found), but random access is O(n) because it must traverse the list. Choose ArrayList when you need frequent reads and occasional writes at the end; opt for LinkedList when you perform many insertions/deletions at the beginning or middle. Also consider memory overhead: ArrayList stores elements in a compact array, while LinkedList has extra overhead for node objects and links.

How can I initialize a list in Java in a single line?

Java offers several concise ways to initialize a list. Using Arrays.asList() returns a fixed-size list backed by the specified array: List<String> list = Arrays.asList("a", "b", "c");. However, this list does not support add/remove operations. List.of() introduced in Java 9 creates an immutable list: List<String> list = List.of("a", "b", "c");. For a mutable, resizable list, use the double-brace pattern new ArrayList<>() {{ add("a"); add("b"); }} (though less recommended due to anonymous inner class overhead), or modern approach: new ArrayList<>(List.of("a", "b", "c")). Remember that Collections.singletonList() creates an immutable single-element list. Choose the method based on whether you need mutability, size, and immutability guarantees.

What is the best way to remove duplicates from an ArrayList?

To remove duplicates while preserving order, the simplest approach is to use a LinkedHashSet: List<T> listWithoutDuplicates = new ArrayList<>(new LinkedHashSet<>(listWithDuplicates));. This creates a set that maintains insertion order and automatically discards duplicates. For streams, use list.stream().distinct().collect(Collectors.toList()) — this also preserves order but returns a new list. If you need to modify the original list in place, you can iterate and use a Set to track seen elements, removing duplicates via Iterator.remove(). Note that duplicates based on custom equality require overriding equals() and hashCode(). For large lists, the set-based approach is O(n) versus O(n²) for nested loops. Performance-wise, LinkedHashSet offers the best balance of speed and order preservation.

How do I sort a list of custom objects by a specific field, like a date?

Sorting a list of custom objects by a field, such as a Date, can be done using Comparator or Comparable. If the class implements Comparable, you can call Collections.sort(list). Otherwise, provide a Comparator: list.sort(Comparator.comparing(MyObject::getDate)) for ascending order. For descending, use Comparator.comparing(MyObject::getDate).reversed(). To find the maximum or minimum date in a list using streams: Date maxDate = list.stream().map(MyObject::getDate).max(Date::compareTo).orElse(null);. If your list is of LocalDate or LocalDateTime, use Comparator.naturalOrder() or Comparator.comparing(...) with method references. For sorting one list based on another, create a custom comparator that maps indices from the second list. Java 8+ streams also allow sorting with sorted() on a stream.

What techniques can I use to find duplicate elements in a list?

Finding duplicates in a list can be done via brute-force nested loops (O(n²)), but more efficient approaches exist. Use a Set to detect duplicates: iterate and attempt to add each element to a HashSet; if add() returns false, it's a duplicate. Collect duplicates into a list: Set<T> seen = new HashSet<>(); List<T> duplicates = list.stream().filter(e -> !seen.add(e)).collect(Collectors.toList());. This runs in O(n). For counting frequencies, use Map<T, Long> freq = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); then filter entries with count > 1. If you only need existence of any duplicate, convert to a set and compare sizes. Note that these methods rely on proper equals()/hashCode() implementations. For primitive-like types, it's straightforward; for custom objects, you may need to define what constitutes a duplicate.

How can I convert a comma-separated String into a List in Java?

To convert a comma-separated string (e.g., "a,b,c") to a list, use Arrays.asList(str.split(",")) — this returns a fixed-size list. For a mutable list, wrap it: new ArrayList<>(Arrays.asList(str.split(","))). If the string may contain spaces around commas, use str.split("\\s*,\\s*") to trim whitespace. For more complex parsing (e.g., quoted values), consider using a CSV library or a custom parser. Java 8 streams allow: Pattern.compile(",").splitAsStream(str).collect(Collectors.toList()). To convert a list back to a comma-separated string: String.join(",", list) or list.stream().collect(Collectors.joining(",")). For immutable lists from List.of(), you cannot modify later. Always consider potential leading/trailing spaces and empty strings. The split() method treats the string as regex, so special characters like backslash require escaping.