Sort Custom Objects in Ascending or Descending Order in Java

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

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.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Build REST APIs with Spring Boot 4, Spring Security 7, and JWT

🆕 High-Demand 80–90% OFF

[NEW] Learn Apache Maven with IntelliJ IDEA and Java 25

🆕 High-Demand 80–90% OFF

ChatGPT + Generative AI + Prompt Engineering for Beginners

🚀 Trending Now 80–90% OFF

Spring 7 and Spring Boot 4 for Beginners (Includes 8 Projects)

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Building Real-Time REST APIs with Spring Boot - Blog App

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Building Microservices with Spring Boot and Spring Cloud

🌟 Top Rated 80–90% OFF
Available in Udemy for Business

Java Full-Stack Developer Course with Spring Boot and React JS

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Build 5 Spring Boot Projects with Java: Line-by-Line Coding

🌟 Top Rated 80–90% OFF

Testing Spring Boot Application with JUnit and Mockito

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Spring Boot Thymeleaf Real-Time Web Application - Blog App

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Master Spring Data JPA with Hibernate

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Spring Boot + Apache Kafka Course - The Practical Guide

🎓 Student Favorite 80–90% OFF
Available in Udemy for Business

Java Testing: Mastering JUnit 5 Framework

🆕 New 80–90% OFF

Reactive Programming in Java: Spring WebFlux and Testing

🌟 Top Rated 80–90% OFF

Spring Boot + RabbitMQ Course - The Practical Guide

🌟 Top Rated 80–90% OFF
Available in Udemy for Business

Functional Programming in Java (Includes Java Collections)

🎓 Student Favorite 80–90% OFF

ChatGPT for Java Developers: Boost Your Productivity with AI

🚀 Trending Now 80–90% OFF