Sort Custom Objects in Ascending or Descending Order in Java

Author:
In this tutorial, we will explore how to sort custom objects in ascending or descending order using Java. We will cover both natural ordering and custom ordering using the Comparable and Comparator interfaces and the Stream API. This tutorial will ensure modern practices and features by using the latest Java version.

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Step-by-Step Guide
    1. Create a Custom Object
    2. Implement Natural Ordering with Comparable
    3. Implement Custom Ordering with Comparator
    4. Sort Objects Using Comparable
    5. Sort Objects Using Comparator
    6. Using Streams for Sorting
  4. Complete Code Example
  5. Conclusion

Introduction

Sorting custom objects in Java requires defining the ordering logic. Java provides the Comparable interface for natural ordering and the Comparator interface for custom ordering. This tutorial will demonstrate how to use both interfaces to sort objects in ascending and descending order.

Prerequisites

Before we start, ensure you have the following:

  • Java Development Kit (JDK) installed (latest version preferred)
  • An Integrated Development Environment (IDE) such as IntelliJ IDEA or Eclipse

Step-by-Step Guide

Step 1: Create a Custom Object

First, let's create a custom object named Person with attributes name and age.

public 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;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

Step 2: Implement Natural Ordering with Comparable

To enable natural ordering, we need to implement the Comparable interface in the Person class. We will sort Person objects by name in a case-insensitive manner and then by age.

public 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) {
        int nameComparison = this.name.compareToIgnoreCase(other.name);
        if (nameComparison != 0) {
            return nameComparison;
        } else {
            return Integer.compare(this.age, other.age);
        }
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

Step 3: Implement Custom Ordering with Comparator

For custom ordering, we will create a comparator to sort Person objects first by name in descending order and then by age in ascending order.

import java.util.Comparator;

public class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        int nameComparison = p2.getName().compareToIgnoreCase(p1.getName());
        if (nameComparison != 0) {
            return nameComparison;
        } else {
            return Integer.compare(p1.getAge(), p2.getAge());
        }
    }
}

Step 4: Sort Objects Using Comparable

Now, we will create a list of Person objects and sort it using the natural ordering defined by the Comparable interface.

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

public class ComparableExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = new ArrayList<>();
        people.add(new Person("Ravi", 25));
        people.add(new Person("Sita", 30));
        people.add(new Person("Arjun", 22));
        people.add(new Person("Lakshmi", 20));
        people.add(new Person("Rahul", 25));

        // Sort the list using the natural ordering
        Collections.sort(people);

        // Print the sorted list
        System.out.println("Sorted by natural ordering: " + people);
    }
}

Step 5: Sort Objects Using Comparator

Next, we will sort the list of Person objects using the custom comparator.

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

public class ComparatorExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = new ArrayList<>();
        people.add(new Person("Ravi", 25));
        people.add(new Person("Sita", 30));
        people.add(new Person("Arjun", 22));
        people.add(new Person("Lakshmi", 20));
        people.add(new Person("Rahul", 25));

        // Sort the list using the custom comparator
        Collections.sort(people, new PersonComparator());

        // Print the sorted list
        System.out.println("Sorted by custom comparator: " + people);
    }
}

Step 6: Using Streams for Sorting

Java Streams provide a concise way to sort collections. We can use the sorted method of the Stream API to sort objects in both ascending and descending order.

Sorting Objects in Ascending Order Using Streams

import java.util.List;
import java.util.stream.Collectors;

public class StreamSortingExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = List.of(
            new Person("Ravi", 25),
            new Person("Sita", 30),
            new Person("Arjun", 22),
            new Person("Lakshmi", 20),
            new Person("Rahul", 25)
        );

        // Sort the list in ascending order using streams
        List<Person> ascendingOrder = people.stream()
            .sorted()
            .collect(Collectors.toList());

        // Print the sorted list
        System.out.println("Ascending Order (Streams): " + ascendingOrder);
    }
}

Sorting Objects in Descending Order Using Streams

public class StreamSortingExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = List.of(
            new Person("Ravi", 25),
            new Person("Sita", 30),
            new Person("Arjun", 22),
            new Person("Lakshmi", 20),
            new Person("Rahul", 25)
        );

        // Sort the list in descending order using streams
        List<Person> descendingOrder = people.stream()
            .sorted(new PersonComparator())
            .collect(Collectors.toList());

        // Print the sorted list
        System.out.println("Descending Order (Streams): " + descendingOrder);
    }
}

Complete Code Example

Here's the complete code example for sorting custom objects in both ascending and descending order using both traditional methods and streams:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

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) {
        int nameComparison = this.name.compareToIgnoreCase(other.name);
        if (nameComparison != 0) {
            return nameComparison;
        } else {
            return Integer.compare(this.age, other.age);
        }
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        int nameComparison = p2.getName().compareToIgnoreCase(p1.getName());
        if (nameComparison != 0) {
            return nameComparison;
        } else {
            return Integer.compare(p1.getAge(), p2.getAge());
        }
    }
}

public class SortingExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = new ArrayList<>();
        people.add(new Person("Ravi", 25));
        people.add(new Person("Sita", 30));
        people.add(new Person("Arjun", 22));
        people.add(new Person("Lakshmi", 20));
        people.add(new Person("Rahul", 25));

        // Sort the list using the natural ordering
        Collections.sort(people);
        System.out.println("Sorted by natural ordering: " + people);

        // Sort the list using the custom comparator
        Collections.sort(people, new PersonComparator());
        System.out.println("Sorted by custom comparator: " + people);

        // Using Streams to sort in ascending order
        List<Person> ascendingOrder = people.stream()
            .sorted()
            .collect(Collectors.toList());
        System.out.println("Ascending Order (Streams): " + ascendingOrder);

        // Using Streams to sort in descending order
        List<Person> descendingOrder = people.stream()
            .sorted(new PersonComparator())
            .collect(Collectors.toList());
        System.out.println("Descending Order (Streams): " + descendingOrder);


 }
}

Conclusion

In this tutorial, we demonstrated how to sort custom objects in ascending and descending order using both traditional methods and Java Streams. We covered natural ordering using the Comparable interface and custom ordering using the Comparator interface. Additionally, we showed how to use the Stream API to achieve the same results in a more concise and readable manner.

This tutorial is SEO-friendly and includes keywords such as "Java object sorting", "ascending order", "descending order", "Comparable", "Comparator", "Stream API", and "Java collections". By following this guide, developers can effectively sort custom objects in their Java applications.

Comments

Post a Comment

Leave Comment