Sorting One List Based on Another List in Java

1. Overview

Sorting a list based on the order of another list is a common task in Java, and various approaches exist to achieve this.

In this tutorial, we’ll see different ways of sorting a list based on another list in Java.

2. Example

Let’s consider a scenario where we’ve got a list of products as productList and another list as shoppingCart, which represents the user’s shopping cart. The shoppingCart contains various product IDs, and we need to display the products in the order they appear in the shopping cart:

List<String> productList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
List<String> shoppingCart = Arrays.asList("Pizza", "Burger", "Fries", "Coke");

In the above example, the productList is the list with actual order, and shoppingCart is the list that needs to be sorted based on the productList. After sorting, the order should be:

Pizza
Burger
Fries
Coke

3. Using a for Loop to Iterate a List

We can use the standard for loop to sort the list based on the other list. In this approach, we create a new list that will return the elements in the sorted order. The loop iterates through the listWithOrder list and adds elements from listToSort to the sortedList in the specified order. The result is a sortedList according to the order of the elements in the listWithOrder list:

List<String> sortUsingForLoop(List<String> listToSort, List<String> listWithOrder) {
    List<String> sortedList = new ArrayList<>();
    for (String element: listWithOrder) {
        if (listToSort.contains(element)) {
            sortedList.add(element);
        }
    }
    return sortedList;
}

Let’s test this approach to sort the above example:

public void givenTwoList_whenUsingForLoop_thenSort() {
    List<String> listWithOrder = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    List<String> listToSort = Arrays.asList("Pizza", "Burger", "Fries", "Coke");
    sortUsingForLoop(listToSort, listWithOrder);
    List<String> expectedSortedList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    assertEquals(expectedSortedList, listWithOrder);
}

4. Using Comparator Interface

In this approach, we’re using the flexibility of Java’s Comparator interface to create a custom comparator. The comparator will be based on the indices of elements in the reference list or list with actual order. Let’s take a look at how it allows us to sort the list:

void sortUsingComparator(List<String> listToSort, List<String> listWithOrder) {
    listToSort.sort(Comparator.comparingInt(listWithOrder::indexOf));
}

The Comparator.comparingInt(listWithOrder::indexOf) construct allows us to sort listToSort list by order of appearance of its elements in listWithOrder.

Let’s use this approach to sort the example discussed above:

public void givenTwoList_whenUsingComparator_thenSort() {
    List<String> listWithOrder = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    List<String> listToSort = Arrays.asList("Pizza", "Burger", "Fries", "Coke");
    sortUsingComparator(listToSort, listWithOrder);
    List<String> expectedSortedList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    assertEquals(expectedSortedList, listToSort);
}

It is a concise and readable solution that avoids the need for additional data structures and provides a clear and straightforward way. However, it’s important to note that the performance may degrade for large lists, as the indexOf() operation has a linear time complexity.

5. Using the Stream API

We can also use the Stream API-based approach for sorting a list based on another list. First, we’ll create a mapping between elements and their indices in listWithOrder through Collectors.toMap() collector. After that, the resultant map will be used to sort listToSort with Comparator.comparingInt() method:

void sortUsingStreamAPI(List<String> listToSort, List<String> listWithOrder) {
    Map<String,Integer> indicesMap = listWithOrder.stream().collect(Collectors.toMap(e -> e, listWithOrder::indexOf));
    listToSort.sort(Comparator.comparingInt(indicesMap::get));
}

Let’s test this approach to sort the above example:

public void givenTwoList_whenUsingStreamAPI_thenSort() {    
    List<String> listWithOrder = Arrays.asList("Burger", "Coke", "Fries", "Pizza");    
    List<String> listToSort = Arrays.asList("Pizza", "Burger", "Fries", "Coke");
    sortUsingCustomComparator(listToSort, listWithOrder);
    List<String> expectedSortedList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    assertEquals(expectedSortedList, listToSort);
}

The Stream API approach provides a clean and modern solution. However, it’s crucial to be mindful of the potential overhead for large lists, as creating the map involves iterating over the entire list.

6. Using a Map

In this approach, we leverage the power of Java’s Map to create a direct mapping between elements in the reference list listWithOrder and their corresponding indices. The key-value pairs in the map consist of elements from listWithOrder as keys and their indices as values:

void sortUsingMap(List<String> listToSort, List<String> listWithOrder) {
    Map<String, Integer> orderedIndicesMap = new HashMap<>();
    for (int i = 0; i < listWithOrder.size(); i++) {
        orderedIndicesMap.put(listWithOrder.get(i), i);
    }
    listToSort.sort(Comparator.comparingInt(orderedIndicesMap::get));
}

Let’s test this approach to sort the above example:

public void givenTwoList_whenUsingMap_thenSort() {
    List<String> listWithOrder = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    List<String> listToSort = Arrays.asList("Pizza", "Burger", "Fries", "Coke");
    sortUsingMap(listToSort, listWithOrder);
    List<String> expectedSortedList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    assertEquals(expectedSortedList, listToSort);
}

The Use of Map provides us with an advantage over the indexOf() method, especially in scenarios involving large lists, repeated lookups, or performance-sensitive applications.

7. Using Guava’s Ordering.explicit()

Guava is a widely used Java library that provides a convenient method for sorting a list based on the order of elements of another list. Let’s start by adding this dependency in our pom.xml file:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.0.0-jre</version>
</dependency>

Guava’s explicit() method allows us to create a comparator based on a specific order. The Ordering class is immutable, so the result will be a new sorted list, and the original list, i.e., listToSort, will remain unchanged.

List<String> sortUsingGuava(List<String> listToSort, List<String> listWithOrder) {
    Ordering<String> explicitOrdering = Ordering.explicit(listWithOrder);
    List<String> sortedList = explicitOrdering.sortedCopy(listToSort);
    return sortedList;
}

In the above example, the sortedCopy() method is responsible for creating a sorted list. Let’s test this approach:

public void givenTwoList_whenUsingGuavaExplicit_thenSort() {
    List<String> listWithOrder = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    List<String> listToSort = Arrays.asList("Pizza", "Burger", "Fries", "Coke");
    sortUsingGuava(listToSort, listWithOrder);
    List<String> expectedSortedList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    assertEquals(expectedSortedList, listWithOrder);
}

8. Using Vavr

Vavr is a functional library for Java 8+ that provides immutable data types and functional control structures. In order to use Vavr, we first need to add this dependency:

<dependency>
    <groupId>io.vavr</groupId>
    <artifactId>vavr</artifactId>
    <version>0.10.4</version>
</dependency>

Vavr provides a sortBy()  method that can be used to sort a list, i.e., listToSort, based on the order specified in another list, i.e., listToOrder. The result will be stored in a new list sortedList, and the original listToSort list will remain unchanged. Let’s see an example using Vavr:

List<String> sortUsingVavr(List<String> listToSort, List<String> listWithOrder) {
    io.vavr.collection.List<String> listWithOrderedElements = io.vavr.collection.List.ofAll(listWithOrder);
    io.vavr.collection.List<String> listToSortElements = io.vavr.collection.List.ofAll(listToSort);
    io.vavr.collection.List<String> sortedList = listToSortElements.sortBy(listWithOrderedElements::indexOf);
    return sortedList.asJava();
}

Let’s test this approach:

public void givenTwoList_whenUsingVavr_thenSort() {
    List<String> listWithOrder = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    List<String> listToSort = Arrays.asList("Pizza", "Burger", "Fries", "Coke");
    sortUsingVavr(listToSort, listWithOrder);
    List<String> expectedSortedList = Arrays.asList("Burger", "Coke", "Fries", "Pizza");
    assertEquals(expectedSortedList, listWithOrder);
}

9. Conclusion

In this tutorial, we explored various approaches for sorting a list based on the order of elements in another list. The choice of the appropriate approach relies on the specific use case based on the simplicity and performance of the solution.