Sorting using `Comparable` and `Comparator`

Sorting using `Comparable` and `Comparator` in Java provides flexibility in sorting objects based on natural ordering (defined by the object itself) or custom ordering (defined externally). Let's explain and demonstrate both:

Sorting Using Comparable:

1. Explanation:

   - Objects implementing `Comparable` interface provide a natural ordering based on their intrinsic properties.

   - The `compareTo()` method is overridden to define how objects should be compared to each other.

2. Demonstration:

   - Let's consider a class `Employee` with properties `id` and `name`. We'll implement `Comparable` to sort employees based on their ids.

   public class Employee implements Comparable<Employee> {

       private int id;

       private String name;

       // Constructor, getters, setters

       @Override

       public int compareTo(Employee other) {

           return Integer.compare(this.id, other.id);

       }

   }

   - Now, we can use `Arrays.sort()` to sort an array of `Employee` objects based on their ids.

   Employee[] employees = {emp1, emp2, emp3};

   Arrays.sort(employees);

Sorting Using Comparator:

1. Explanation:

   - `Comparator` interface provides a way to define custom sorting logic externally, independent of the object being sorted.

   - Custom `Comparator` implementations can be provided for different sorting criteria.

2. Demonstration:

   - Let's continue with the `Employee` class. Now, we want to sort employees based on their names. We'll implement a custom `Comparator` for this.

   public class NameComparator implements Comparator<Employee> {

       @Override

       public int compare(Employee emp1, Employee emp2) {

           return emp1.getName().compareTo(emp2.getName());

       }

   }

   - We can then use this comparator with `Arrays.sort()` to sort employees by name.

   Employee[] employees = {emp1, emp2, emp3};

   Arrays.sort(employees, new NameComparator());

Comparison:

- Comparable:

  - Used when objects have a natural ordering.

  - Changes to the class itself.

  - One default ordering.

- Comparator:

  - Used for custom ordering or when objects don't implement `Comparable`.

  - No changes to the class being sorted.

  - Multiple custom orderings possible.

Complete Example:

import java.util.Arrays;

import java.util.Comparator;

class Employee implements Comparable<Employee> {

    private int id;

    private String name;

    public Employee(int id, String name) {

        this.id = id;

        this.name = name;

    }

    // Getters, setters, etc.

    @Override

    public int compareTo(Employee other) {

        return Integer.compare(this.id, other.id);

    }

    @Override

    public String toString() {

        return "Employee{" +

                "id=" + id +

                ", name='" + name + '\'' +

                '}';

    }

}

class NameComparator implements Comparator<Employee> {

    @Override

    public int compare(Employee emp1, Employee emp2) {

        return emp1.getName().compareTo(emp2.getName());

    }

}

public class SortingDemo {

    public static void main(String[] args) {

        Employee[] employees = {

                new Employee(3, "John"),

                new Employee(1, "Alice"),

                new Employee(2, "Bob")

        };

        // Sorting using Comparable (by id)

        Arrays.sort(employees);

        System.out.println("Sorted by id:");

        for (Employee emp : employees) {

            System.out.println(emp);

        }

        // Sorting using Comparator (by name)

        Arrays.sort(employees, new NameComparator());

        System.out.println("\nSorted by name:");

        for (Employee emp : employees) {

            System.out.println(emp);

        }

    }

}

This example demonstrates sorting `Employee` objects both by their ids (using `Comparable`) and by their names (using `Comparator`).