Java Program to Sort the Array Elements in Descending Order

Sorting array elements is a common operation in programming that rearranges the elements of an array in a specific order. While ascending order is the most common sorting order, there are scenarios where sorting an array in descending order is required, such as prioritizing larger values. Java provides various ways to sort arrays, including utility methods from the Arrays class and custom sorting algorithms. This blog post will demonstrate how to sort an array in descending order using Java, focusing on a straightforward approach with the Arrays class and a custom comparator.

Program Steps

1. Create an array of integers.

2. Use the Arrays.sort() method along with a custom comparator to sort the array in descending order.

3. Display the sorted array.

Code Program

import java.util.Arrays;
import java.util.Collections;

public class SortArrayDescending {
    public static void main(String[] args) {
        // Step 1: Creating an array of integers
        Integer[] numbers = {3, 7, 2, 15, 10};

        // Step 2: Using Arrays.sort() method with a custom comparator for descending order
        Arrays.sort(numbers, Collections.reverseOrder());

        // Step 3: Displaying the sorted array
        System.out.println("Array elements in descending order: " + Arrays.toString(numbers));
    }
}

Output:

Array elements in descending order: [15, 10, 7, 3, 2]

Explanation:

1. The program begins by defining an array of Integer named numbers. It's important to use the Integer type (wrapper class for int) because the Arrays.sort() method with a custom comparator does not work with arrays of primitive types like int.

2. The Arrays.sort() method is used to sort the array. By default, this method sorts the array in ascending order. However, by passing Collections.reverseOrder() as the second argument, which serves as a comparator, we instruct the method to sort the array in descending order instead. This approach is concise and leverages Java's standard library for sorting.

3. Finally, the sorted array is printed using Arrays.toString(numbers), which converts the array into a string representation, allowing it to be printed in a readable format.

4. This example demonstrates an efficient way to sort array elements in descending order using Java's Arrays.sort() method with a custom comparator, showcasing the flexibility and power of Java's sorting utilities.

Sorting an Array in Descending Order Without Using Built-in Functions 

Sorting an array in descending order without using built-in functions is a fundamental exercise in understanding sorting algorithms. This section will illustrate how to manually implement a sorting algorithm to sort array elements in descending order, specifically focusing on the selection sort technique for its simplicity and educational value.

Program Steps

1. Create an array of integers.

2. Implement the selection sort algorithm to sort the array in descending order.

3. Iterate through the array to swap elements based on their value, ensuring the highest values bubble to the front.

4. Display the sorted array.

Code Program

public class SortArrayDescendingWithoutBuiltIn {
    public static void main(String[] args) {
        // Step 1: Creating an array of integers
        int[] numbers = {3, 7, 2, 15, 10};

        // Step 2: Implementing the selection sort algorithm for descending order
        for (int i = 0; i < numbers.length - 1; i++) {
            // Assume the first element is the largest
            int index = i;
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] > numbers[index]) {
                    // Find the largest element in the rest of the array
                    index = j;
                }
            }

            // Step 3: Swapping the largest element with the first element of the unsorted part
            int largerNumber = numbers[index];
            numbers[index] = numbers[i];
            numbers[i] = largerNumber;
        }

        // Step 4: Displaying the sorted array
        System.out.print("Array elements in descending order: ");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

Output:

Array elements in descending order: 15 10 7 3 2

Explanation:

1. The program starts by defining an integer array numbers containing unsorted elements.

2. The selection sort algorithm is manually implemented to sort the array in descending order. It works by iteratively moving through the array, selecting the largest element from the unsorted section, and swapping it with the first element of the unsorted section.

3. In each iteration of the outer loop, the inner loop searches for the largest element in the unsorted portion of the array (numbers[j] > numbers[index]). When the largest element is found, its index is stored in index.

4. After finding the largest element in the unsorted section, it is swapped with the first element of the unsorted section. This is achieved by temporarily storing the larger number in largerNumber, then swapping the elements at index and i.

5. The outer loop continues until the array is sorted in descending order. The sorted array is then printed element by element in the final step.

6. This example demonstrates how to sort an array in descending order without using built-in functions, providing a clear example of the selection sort algorithm's application.