The Ultimate Guide to Java Collection Sorting

In this comprehensive guide, we will explore the ins and outs of Java collection sorting, covering everything from sorting basics to advanced techniques. By the end, you’ll be equipped with the knowledge and tools to sort Java collections like a pro.

In the world of Java programming, sorting collection is a fundamental task that every developer encounters at some point.

Whether you’re dealing with lists, sets, or maps, having a solid understanding of how to sort these data structures is essential.

Also Read: write a program to display number 1 to 50 using do while loop

Introduction

Java provides a rich set of APIs for working with collection, and sorting is no exception.

Sorting a collection involves arranging its elements in a specific order, which could be ascending or descending based on certain criteria.

By leveraging Java’s built-in sorting capabilities, we can efficiently organize and manipulate data in various scenarios.

Sorting Lists in Java

Sorting Lists of Objects

When it comes to sorting lists of objects in Java, the process is straightforward.

The Collections class, part of the Java Collections Framework, provides a convenient method called sort() that enables us to sort lists effortlessly.

Let’s take a look at an example:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListSortingExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Orange");
        fruits.add("Banana");
        fruits.add("Mango");

        Collections.sort(fruits);

        System.out.println(fruits);
    }
}

The output will be:

[Apple, Banana, Mango, Orange]

In the above example, we create an ArrayList of String objects representing fruits. By calling the sort() method from the Collections class, the list is sorted in its natural ordering, which is lexicographical order for strings.

Also Read: java program to find factorial of a number using command line argument

Sorting Lists of Primitives

Sorting lists of primitive types, such as integers or doubles, follows a similar approach. However, since primitive types are not objects, we need to use their wrapper classes.

Let’s see an example of sorting a list of integers:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class PrimitiveListSortingExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(5);
        numbers.add(8);
        numbers.add(3);

        Collections.sort(numbers);

        System.out.println(numbers);
    }
}

The output will be:

[3, 5, 8, 10]

In the above example, we create an ArrayList of Integer objects representing numbers. By invoking the sort() method, the list is sorted in ascending order.

Also Read: 19 Pythonic Ways to Replace if-else Statements

Sorting Sets in Java

Sorting Sets of Objects

Sets in Java are unordered collections that do not allow duplicate elements.

While they don’t have a natural ordering, we can still sort sets by converting them to lists and then applying the sorting operation.

Let’s consider an example:

import java.util.*;

public class SetSortingExample {
    public static void main(String[] args) {
        Set<String> names = new HashSet<>();
        names.add("John");
        names.add("Alice");
        names.add("Bob");
        names.add("Emily");

        List<String> sortedList = new ArrayList<>(names);
        Collections.sort(sortedList);

        System.out.println(sortedList);
    }
}

The output will be:

[Alice, Bob, Emily, John]

In the above example, we convert the set of names into a list, sort the list using the Collections.sort() method, and obtain the sorted names in lexicographical order.

Also Read: GitHub: Revolutionizing Collaboration in Software Development

Sorting Sets of Primitives

Since sets don’t allow duplicate elements, sorting sets of primitive types is relatively straightforward. We can convert the set to a list, sort it, and then create a new set from the sorted list.

Here’s an example:

import java.util.*;

public class PrimitiveSetSortingExample {
    public static void main(String[] args) {
        Set<Integer> numbers = new HashSet<>();
        numbers.add(10);
        numbers.add(5);
        numbers.add(8);
        numbers.add(3);

        List<Integer> sortedList = new ArrayList<>(numbers);
        Collections.sort(sortedList);

        Set<Integer> sortedSet = new LinkedHashSet<>(sortedList);

        System.out.println(sortedSet);
    }
}


The output will be:

[3, 5, 8, 10]

In the above example, we convert the set of numbers into a list, sort the list using the Collections.sort() method, and then construct a new LinkedHashSet from the sorted list to preserve the order.

Sorting Maps in Java

Sorting maps in Java is a bit more involved than sorting lists or sets. While the Java Collections Framework doesn’t offer direct methods for sorting maps, we can utilize workarounds to achieve the desired result.

Sorting Maps by Keys

To sort a map by its keys, we can utilize the TreeMap class, which implements the SortedMap interface and automatically maintains the elements in ascending order based on their keys.

Let’s see an example:

import java.util.*;

public class MapSortingByKeyExample {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("John", 30);
        ages.put("Alice", 25);
        ages.put("Bob", 35);
        ages.put("Emily", 28);

        Map<String, Integer> sortedMap = new TreeMap<>(ages);

        for (Map.Entry<String, Integer> entry : sortedMap.entrySet()) {
            System.out.println(entry.getKey() + " - " + entry.getValue());
        }
    }
}


The output will be:

Alice - 25
Bob - 35
Emily - 28
John - 30

In the above example, we create a TreeMap from the original map, ages. The TreeMap automatically sorts the entries based on the keys in ascending order.

Sorting Maps by Values

Sorting a map by its values requires a slightly different approach.

We cannot directly sort a map by its values using the Java Collections Framework. However, we can use a workaround by creating a list of map entries, sorting the list based on values, and then constructing a new map from the sorted entries.

Here’s an example:

import java.util.*;

public class MapSortingByValueExample {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("John", 30);
        ages.put("Alice", 25);
        ages.put("Bob", 35);
        ages.put("Emily", 28);

        List<Map.Entry<String, Integer>> sortedList = new ArrayList<>(ages.entrySet());
        Collections.sort(sortedList, new ValueComparator());

        Map<String, Integer> sortedMap = new LinkedHashMap<>();

        for (Map.Entry<String, Integer> entry : sortedList) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        for (Map.Entry<String, Integer> entry : sortedMap.entrySet()) {
            System.out.println(entry.getKey() + " - " + entry.getValue());
        }
    }
}

class ValueComparator implements Comparator<Map.Entry<String, Integer>> {
    @Override
    public int compare(Map.Entry<String, Integer> entry1, Map.Entry<String, Integer> entry2) {
        return entry1.getValue().compareTo(entry2.getValue());
    }
}


The output will be:

Alice - 25
Emily - 28
John - 30
Bob - 35

In the above example, we create a list of map entries from the original map, ages.

We then sort the list using a custom ValueComparator that compares the values of the entries.

Finally, we construct a new LinkedHashMap and populate it with the sorted entries to maintain the order.

Advanced Sorting Techniques

Custom Sorting with Comparable and Comparator

Java allows us to define custom sorting logic by implementing the Comparable interface or using the Comparator interface.

The Comparable interface is used to establish the natural ordering of objects, while the Comparator interface provides a way to define custom comparison logic for objects that don’t implement Comparable or when we need multiple sorting criteria.

Let’s see an example of custom sorting using the Comparable interface:

import java.util.*;

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        return this.name.compareTo(other.getName());
    }
}

public class CustomSortingExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 30));
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 35));
        people.add(new Person("Emily", 28));

        Collections.sort(people);

        for (Person person : people) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}


The output will be:

Alice - 25
Bob - 35
Emily - 28
John - 30

In the above example, the Person class implements the Comparable interface and overrides the compareTo() method to compare instances based on their names.

Now, let’s explore an example of custom sorting using the Comparator interface:

import java.util.*;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class CustomComparatorExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 30));
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 35));
        people.add(new Person("Emily", 28));

        Collections.sort(people, new AgeComparator());

        for (Person person : people) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return Integer.compare(person1.getAge(), person2.getAge());
    }
}


The output will be:

Alice - 25
Emily - 28
John - 30
Bob - 35

In the above example, we define a custom AgeComparator class that implements the Comparator interface.

The compare() method compares instances based on their ages.

Sorting with the Stream API

Java 8 introduced the Stream API, which provides a declarative and functional way to perform operations on collections, including sorting.

The Stream API allows us to chain multiple operations together, making the code more readable and concise.

Here’s an example of sorting a list of names using the Stream API:

import java.util.*;

public class StreamSortingExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Emily");

        List<String> sortedNames = names.stream()
                .sorted()
                .toList();

        System.out.println(sortedNames);
    }
}


The output will be:

[Alice, Bob, Emily, John]

In the above example, we convert the list of names into a stream, apply the sorted() operation to sort the names lexicographically, and finally collect the sorted names into a new list using the toList() collector.

FAQs about Java Collection Sorting

Conclusion

Sorting collections is an essential skill for Java developers, as it enables efficient data organization and manipulation. In this ultimate guide to Java collection sorting, we covered the basics of sorting lists, sets, and maps, as well as advanced techniques using custom comparators and the Stream API. With this knowledge, you’ll be able to confidently sort Java collections and build robust applications that handle data effectively.