How to sort array in descending order - Java Example

It's easy to sort an object array in decreasing or reverse order, just provide the Comparator with opposite order. You can even use Collections.reverseOrder() if you want to sort array in the decreasing order, which returns a reverse Comparator to sort objects in the order opposite of their natural ordering defined by the compareTo() method. Unfortunately, for a primitive array, there is no direct way to sort in descending order. The Arrays.sort() method which is used to sort a primitive array in Java doesn't accept a boolean to sort the primitive array in reverse order. You might have seen the error "no suitable method found for sort(int[],comparator<object>)" which occurs when programmers try to call the Arrays.sort() method by passing reverse Comparator defined by Collection.reverseOrder(). That will work fine with Integer array but will not work with an int array. The only way to sort a primitive array in descending order is, first sort the array in ascending order and then reverse the array in place as shown here. This is also true for two-dimensional primitive arrays.



How to sort object array in descending order

First, let's see the example of sorting an object array into ascending order. Then we'll see how to sort a primitive array in descending order. In order to sort a reference type array e.g. String array, Integer array or Employee array, you need to pass the Array.sort() method a reverse Comparator.

Fortunately, you don't need to code it yourself, you can use Collections.reverseOrder(Comparator comp) to get a reverse order Comparator. Just pass your Comparator to this method and it will return the opposite order Comparator.

If you are using Comparator method to sort in natural order, you can also use the overloaded Collection.reverseOrder() method. It returns a Comparator which sorts in the opposite of natural order. In fact, this is the one you will be using most of the time.


Here is an example of sorting Integer array in descending order:

Integer[] cubes = new Integer[] { 8, 27, 64, 125, 256 };
Arrays.sort(cubes, Collections.reverseOrder());

Now the cubes array will be {256, 125, 64, 27,8}, you can see the order is reversed and elements are sorted in decreasing order. Sometimes, you use your own customized Comparator e.g. a comparator we have used to sort Employee by their salary. If you are using that one then you need to call the Array.sort() method as follows

Arrays.sort(emp[], Collections.sort(SALARY_CMP));

where SALARY_CPM is the Comparator which orders employee by their salary. You can see the Core Java Volume 1 - Fundamentals by Cay S. Horstmann to learn more about how to sort objects in Java.

How to sort an array in decreasing order in Java



How to sort primitive array in descending order

Now, let's see how to sort a primitive array e.g. int[], long[],  float[] or char[] in descending order. As I told, there are no Arrays.sort() method which can sort the array in the reverse order. Many programmers make mistake of calling the above Array.sort() method as follows:

int[] squares = { 4, 25, 9, 36, 49 };
Arrays.sort(squares, Collections.reverseOrder());

This is compile time error "The method sort(int[]) in the type Arrays is not applicable for the arguments (int[], Comparator<Object>)" because there is no such method in the java.util.Arrays class.

The only way to sort a primitive array in descending order is first to sort it in ascending order and then reverse the array in place as shown here. Since in place reversal is an efficient algorithm and doesn't require extra memory, you can use it sort and reverse large array as well. You can also see a good book on data structure and algorithm e.g. Introduction to Algorithms to learn more about efficient sorting algorithm e.g. O(n) sorting algorithm like Bucket sort.

sorting primitive array in descending order in Java




Java Program to reverse an array in descending order

Here is complete Java program to sort an object array and a primitive array in the reverse order in Java. As I told it's easy to sort a reference array to decreasing order because you can supply a reverse Comparator by using Collections.reverseOrder() method, but it's tricky to sort the primitive array in reverse order. The only way to achieve that is first by sorting the array in increasing order and then reverse the array in place and that what I have done in this example.

I have used Arrays.sort() method to sort a primitive array in ascending order and then written a reverse() method to reverse the array in place. Since there are eight primitive types in Java, you need to write separate reverse methods to reverse a byte array, long array or a float array.

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

/*
 * Java Program to sort the array in descending order.
 * Object array can be sorted in reverse order by using
 * Array.sort(array, Comparator) method but primitive
 * array e.g. int[] or char[] can only be sorted
 * in ascending order. For opposite order, just
 * reverse the array. 
 * 
 */

public class ArraySorter {

  public static void main(String[] args) {

    // sorting Integer array in descending order
    Integer[] cubes = new Integer[] { 8, 27, 64, 125, 256 };
    System.out.println("Integer array before sorting : "
        + Arrays.toString(cubes));
    System.out.println("sorting array in descending order");

    Arrays.sort(cubes, Collections.reverseOrder());
    System.out.println("array after sorted in reverse order: "
        + Arrays.toString(cubes));

    // sorting primitive array int[] in descending order
    int[] squares = { 4, 25, 9, 36, 49 };

    System.out.println("int[] array before sorting : "
        + Arrays.toString(squares));
    System.out.println("sorting array in ascending order");

    Arrays.sort(squares, Collections.reverseOrder());
    System.out.println("reversing array in place");
    reverse(squares);
    System.out.println("Sorted array in descending order : "
        + Arrays.toString(squares));

  }

  /**
   * reverse given array in place
   * 
   * @param input
   */
  public static void reverse(int[] input) {
    int last = input.length - 1;
    int middle = input.length / 2;
    for (int i = 0; i <= middle; i++) {
      int temp = input[i];
      input[i] = input[last - i];
      input[last - i] = temp;
    }
  }

}

Output
Integer array before sorting : [8, 27, 64, 125, 256]
sorting array in descending order
array after sorted in reverse order: [256, 125, 64, 27, 8]
int[] array before sorting : [4, 25, 9, 36, 49]
sorting an array in ascending order
reversing array in place
Sorted array in descending order : [49, 36, 25, 9, 4]


That's all about how to sort an array in descending order in Java. You can use a reverse Comparator or Collections.reverseOrder() method to sort an object array in descending order e.g. String array, Integer array or Double array. The Arrays.sort() method is overloaded to accept a Comparator, which can also be a reverse Comparator. Now, to sort a primitive array in decreasing order, there is no direct way. You first need to sort it on ascending or normal order and then reverse the array in place. The in-place algorithm is an efficient way to reverse array and doesn't require extra memory, so it can also be used to reverse a large array.


Other Java array tutorials you may like:
  • How to declare and initialize a two-dimensional array in Java? (solution)
  • How to convert an array to String in Java? (solution)
  • How to test if an array contains a value in Java? (solution)
  • 22 Array concepts Interview Questions in Java? (answer)
  • How to print elements of an array in Java? (example)
  • What is the difference between array and ArrayList in Java? (answer)
  • How to loop over an array in Java? (solution)
  • How to find duplicate elements in Java array? (answer)
  • How to remove duplicate objects from an array in Java? (answer)


No comments:

Post a Comment