Java Program To Sort The Elements Of An Array In Descending Order

Sorting arrays is a fundamental operation in programming, essential for organizing data efficiently. In Java, there are several convenient ways to arrange array elements in descending order, from largest to smallest.

In this article, you will learn how to sort an array of elements in descending order using various Java approaches, providing practical examples and clear explanations.

Problem Statement

The core problem involves reordering a given array of elements such so that the largest element appears first, followed by successively smaller elements, until the smallest element is at the end. This is a common requirement in many applications, such as:

• Displaying scores on a game leaderboard.
• Listing product prices from highest to lowest.
• Presenting financial data by value in a downward trend.

Ensuring data is sorted correctly is crucial for readability, analysis, and optimal user experience.

Example

Consider an initial array: [5, 1, 9, 3, 7]

After sorting in descending order, the array should become: [9, 7, 5, 3, 1]

Background & Knowledge Prerequisites

To understand the array sorting methods discussed, familiarity with the following Java concepts is beneficial:

• Arrays: Basic understanding of how arrays work in Java.
• Loops: for loops for iterating through arrays.
• java.util.Arrays class: Especially the sort() method.
• java.util.Collections class: Particularly reverseOrder() for comparators.
• Wrapper Classes: Understanding int vs. Integer and how autoboxing/unboxing works.
• Lambda Expressions (Optional): For custom sorting logic.

Use Cases or Case Studies

Sorting arrays in descending order has numerous practical applications across various domains:

• Leaderboards in Games: Displaying player scores from the highest to the lowest, allowing users to quickly see top performers.
• Product Catalogs: Sorting products by price (highest to lowest), customer ratings, or popularity to highlight premium or best-selling items.
• Financial Reporting: Presenting financial transactions, stock values, or sales figures from largest to smallest to emphasize major impacts.
• Data Analysis: Organizing datasets by a specific metric in descending order to identify top contributors or significant outliers.
• Search Engine Results: Ranking search results by relevance or recency, with the most relevant items appearing first.

Solution Approaches

Here are three effective approaches to sort an array in descending order in Java, each suitable for different scenarios.

Approach 1: Sort Ascending and Manually Reverse (for int[])

This method first sorts a primitive int array in its natural ascending order using Arrays.sort(), and then manually reverses the order of elements to achieve a descending sort.

• Summary: Sorts a primitive array in ascending order and then reverses it in place.

// SortPrimitiveArrayDescending
import java.util.Arrays;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize a primitive integer array
        int[] numbers = {5, 1, 9, 3, 7};
        System.out.println("Original array: " + Arrays.toString(numbers));

        // Step 2: Sort the array in ascending order
        Arrays.sort(numbers);
        System.out.println("Array sorted ascending: " + Arrays.toString(numbers));

        // Step 3: Manually reverse the sorted array to get descending order
        int n = numbers.length;
        for (int i = 0; i < n / 2; i++) {
            int temp = numbers[i];
            numbers[i] = numbers[n - 1 - i];
            numbers[n - 1 - i] = temp;
        }

        // Step 4: Print the array after reversing
        System.out.println("Array sorted descending: " + Arrays.toString(numbers));
    }
}

Run

Sample Output:

Original array: [5, 1, 9, 3, 7]
Array sorted ascending: [1, 3, 5, 7, 9]
Array sorted descending: [9, 7, 5, 3, 1]

Stepwise Explanation:

1. Initialize Array: A primitive int array numbers is created.
2. Sort Ascending: Arrays.sort(numbers) arranges the elements from smallest to largest.
3. Manual Reverse: A for loop iterates through the first half of the array. In each iteration, it swaps the element at i with the element at n - 1 - i (where n is the array length). This effectively reverses the array.

Approach 2: Using Arrays.sort() with Collections.reverseOrder() (for Integer[])

For arrays of wrapper objects (like Integer[]) or any Object[] where elements are Comparable, Java provides a direct way to sort in descending order using Collections.reverseOrder(). This method cannot be used directly with primitive arrays (int[]).

• Summary: Sorts an Integer array directly in descending order using a built-in Comparator.

// SortObjectArrayDescending
import java.util.Arrays;
import java.util.Collections;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize an Integer array (wrapper type)
        Integer[] numbers = {5, 1, 9, 3, 7};
        System.out.println("Original array: " + Arrays.toString(numbers));

        // Step 2: Sort the Integer array in descending order
        // Collections.reverseOrder() provides a Comparator for reverse sorting
        Arrays.sort(numbers, Collections.reverseOrder());

        // Step 3: Print the array after sorting
        System.out.println("Array sorted descending: " + Arrays.toString(numbers));
    }
}

Run

Sample Output:

Original array: [5, 1, 9, 3, 7]
Array sorted descending: [9, 7, 5, 3, 1]

Stepwise Explanation:

1. Initialize Wrapper Array: An array of Integer objects (Integer[]) is created. This is crucial as Collections.reverseOrder() works with object arrays.
2. Sort Descending: Arrays.sort(numbers, Collections.reverseOrder()) sorts the array. Collections.reverseOrder() returns a Comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface (which Integer does).

Approach 3: Using a Custom Comparator (Lambda Expression) for Integer[]

For more fine-grained control over sorting logic, or when sorting custom objects, a custom Comparator can be defined. With Java 8 and later, lambda expressions provide a concise way to do this.

• Summary: Defines a custom comparison logic using a lambda expression to sort an Integer array in descending order.

// SortWithCustomComparator
import java.util.Arrays;
import java.util.Comparator;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize an Integer array
        Integer[] numbers = {5, 1, 9, 3, 7};
        System.out.println("Original array: " + Arrays.toString(numbers));

        // Step 2: Define a custom Comparator using a lambda expression for descending order
        // (a, b) -> b.compareTo(a) means: if b is greater than a, b comes first
        Comparator<Integer> descendingComparator = (a, b) -> b.compareTo(a);

        // Step 3: Sort the array using the custom comparator
        Arrays.sort(numbers, descendingComparator);

        // Step 4: Print the array after sorting
        System.out.println("Array sorted descending: " + Arrays.toString(numbers));
    }
}

Run

Sample Output:

Original array: [5, 1, 9, 3, 7]
Array sorted descending: [9, 7, 5, 3, 1]

Stepwise Explanation:

1. Initialize Wrapper Array: An array of Integer objects is created.
2. Define Custom Comparator: A Comparator is defined using a lambda expression (a, b) -> b.compareTo(a).

• a.compareTo(b) returns a negative integer if a < b, zero if a == b, and a positive integer if a > b. This is for ascending.
• b.compareTo(a) inverts this logic, making b come before a if b is naturally greater than a, thus achieving descending order.

1. Sort with Comparator: Arrays.sort(numbers, descendingComparator) applies this custom logic to sort the array.

Conclusion

Sorting an array in descending order is a common task in Java programming, and the java.util.Arrays and java.util.Collections classes provide powerful tools to achieve this efficiently. While primitive arrays require a manual reversal step or conversion to wrapper types, object arrays offer more direct methods using Collections.reverseOrder() or custom Comparators. Choosing the right approach depends on whether you are working with primitive or wrapper types and the level of custom sorting logic required.

Summary

• Primitive int[]: Sort ascending using Arrays.sort() and then manually reverse the array elements.
• Wrapper Integer[] (or other Comparable objects): Use Arrays.sort(array, Collections.reverseOrder()) for a direct descending sort.
• Custom Logic for Integer[] (or custom objects): Implement a custom Comparator, often concisely with a lambda expression like (a, b) -> b.compareTo(a), and pass it to Arrays.sort().