Great! Let’s explore Advanced Sorting in Java. While basic sorting is often achieved with methods like Arrays.sort(), Java offers powerful tools for customized sorting, such as sorting with comparators and lambda expressions. We can also use streams for advanced sorting. Let’s break it down!

1. Sorting with Comparator

You can use a Comparator to define your custom sorting logic.

Example: Sorting Objects Using Comparator

Let’s consider a Person class where we sort people by age or name.

import java.util.*;class Person {    String name;    int age;    Person(String name, int age) {        this.name = name;        this.age = age;    }    public String toString() {        return name + " (" + age + ")";    }}public class AdvancedSorting {    public static void main(String[] args) {        List<Person> people = new ArrayList<>();        people.add(new Person("Alice", 30));        people.add(new Person("Bob", 20));        people.add(new Person("Charlie", 25));        // Sorting by Age using Comparator        System.out.println("Sorting by Age:");        people.sort(Comparator.comparingInt(person -> person.age)); // Sort by age        people.forEach(System.out::println);        // Sorting by Name using Comparator        System.out.println("\nSorting by Name:");        people.sort(Comparator.comparing(person -> person.name)); // Sort by name        people.forEach(System.out::println);    }}

Output:

Sorting by Age:Bob (20)Charlie (25)Alice (30)Sorting by Name:Alice (30)Bob (20)Charlie (25)

2. Sorting with Lambda Expressions

Java allows you to write concise sorting logic using lambda expressions, which are often used in combination with Comparator.

Example: Sorting a List of Strings Using Lambda Expression

import java.util.*;public class LambdaSorting {    public static void main(String[] args) {        List<String> names = new ArrayList<>();        names.add("Charlie");        names.add("Alice");        names.add("Bob");        // Sorting using lambda expression        names.sort((a, b) -> a.compareTo(b)); // Ascending order        System.out.println("Sorted Names:");        names.forEach(System.out::println);    }}

Output:

Sorted Names:AliceBobCharlie

You can reverse the order easily with:

names.sort((a, b) -> b.compareTo(a)); // Descending order

3. Sorting Using Streams (Java 8+)

Java 8 introduced streams, which allow sorting in a more declarative and functional style.

Example: Sorting with Streams

import java.util.*;import java.util.stream.*;public class StreamSorting {    public static void main(String[] args) {        List<String> names = Arrays.asList("Charlie", "Alice", "Bob");        // Sorting with streams (ascending)        names.stream()             .sorted()             .forEach(System.out::println);        System.out.println("\nSorted in Descending Order:");                // Sorting with streams (descending)        names.stream()             .sorted(Comparator.reverseOrder())             .forEach(System.out::println);    }}

Output:

AliceBobCharlieSorted in Descending Order:CharlieBobAlice

4. Sorting by Multiple Criteria

You can also combine multiple criteria in your sorting logic using thenComparing in Comparator.

Example: Sorting by Age and then Name

import java.util.*;class Person {    String name;    int age;    Person(String name, int age) {        this.name = name;        this.age = age;    }    public String toString() {        return name + " (" + age + ")";    }}public class MultiCriteriaSorting {    public static void main(String[] args) {        List<Person> people = new ArrayList<>();        people.add(new Person("Alice", 30));        people.add(new Person("Bob", 20));        people.add(new Person("Charlie", 30));        // Sorting by Age, then by Name        people.sort(Comparator.comparingInt((Person p) -> p.age)                              .thenComparing(p -> p.name)); // Multi-level sort        people.forEach(System.out::println);    }}

Output:

Bob (20)Alice (30)Charlie (30)

5. Custom Sorting with Comparator and Nulls

Java provides functionality to handle null values while sorting.

Example: Sorting with Nulls First or Last

import java.util.*;public class NullHandlingSorting {    public static void main(String[] args) {        List<String> names = new ArrayList<>();        names.add(null);        names.add("Alice");        names.add("Bob");        names.add(null);        // Sorting with null values first        names.sort(Comparator.nullsFirst(Comparator.naturalOrder()));        System.out.println("Sorted with Nulls First: " + names);        // Sorting with null values last        names.sort(Comparator.nullsLast(Comparator.naturalOrder()));        System.out.println("Sorted with Nulls Last: " + names);    }}

Output:

Sorted with Nulls First: [null, null, Alice, Bob]Sorted with Nulls Last: [Alice, Bob, null, null]

Summary of Advanced Sorting Techniques:

• Comparator: Allows custom sorting logic for objects.

• Lambda Expressions: Provides concise, inline sorting functions.

• Streams: A functional approach to sorting collections, often used in conjunction with filter, map, and other stream operations.

• Multi-criteria Sorting: Chain multiple comparison criteria using thenComparing.

• Null Handling: Use Comparator.nullsFirst() or Comparator.nullsLast() to handle null values.

Would you like to see an example of sorting with custom comparators or sorting large datasets efficiently? Let me know! ?