How to Compare Two Lists in Java 8

Comparing two lists is a common task in Java development. This article explores various techniques to compare lists in Java 8, focusing on efficiency and clarity. We’ll cover methods for checking equality, finding differences (additional and missing items), and identifying common elements.

Comparing Lists for Equality

Using the equals() Method

The simplest approach is using the List.equals() method. This method returns true if both lists have the same size and contain the same elements in the same order. However, this requires sorting the lists first if order isn’t important.

List<String> list1 = new ArrayList<>(Arrays.asList("a", "b", "c"));
List<String> list2 = new ArrayList<>(Arrays.asList("c", "b", "a"));

Collections.sort(list1);
Collections.sort(list2);

boolean isEqual = list1.equals(list2); // true after sorting

Using CollectionUtils.isEqualCollection()

Apache Commons Collections provides the CollectionUtils.isEqualCollection() method, which compares lists irrespective of order. This simplifies comparison when the element sequence doesn’t matter.

boolean isEqual = CollectionUtils.isEqualCollection(list1, list2); // true without sorting

Comparing in Unit Tests

For unit testing, consider using Matchers.containsInAnyOrder() from AssertJ or Hamcrest. This assertion verifies that lists contain the same elements regardless of their order.

assertThat(list1, containsInAnyOrder(list2.toArray()));

Finding Differences Between Two Lists

Using removeAll()

To find elements present in list1 but not in list2, use the removeAll() method. This modifies list1 to contain only the difference.

List<String> list1 = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
List<String> list2 = new ArrayList<>(Arrays.asList("a", "b", "e", "f"));

list1.removeAll(list2); // list1 now contains [c, d]

Leveraging Java Streams

Java 8 Streams offer a more elegant solution:

List<String> difference = list1.stream()
                              .filter(item -> !list2.contains(item))
                              .collect(Collectors.toList());

This filters list1, keeping only elements not found in list2. The result is a new list containing the difference. To find elements missing in list1 but present in list2, simply reverse the roles of the lists in the code. CollectionUtils.removeAll() offers a similar solution without modifying the original lists.

Finding Common Elements

Using retainAll()

The retainAll() method modifies list1 to keep only elements present in both lists.

list1.retainAll(list2); // list1 now contains [a, b]

Using Java Streams for Intersection

Streams provide a functional approach for intersection:

List<String> commonElements = list1.stream()
                                  .filter(list2::contains)
                                  .collect(Collectors.toList());

CollectionUtils.intersection() also provides this functionality without modifying the original lists.

Conclusion

Java 8 offers various techniques for comparing lists, each with its own strengths. Choosing the appropriate method depends on the specific comparison requirements and the desired outcome. Whether checking for equality, finding differences, or identifying common elements, understanding these methods enables efficient and clean list manipulation in Java.