How to sort an Array in descending order in Java - Example

Sorting an array is one of the common tasks in Programming and you have many algorithms to sort an array like QuickSort, MergeSort which provides O(NLogN) time performance and Bucket Sort, Counting Sort and Radix Sort algorithms which can even sort some array in O(N) time. But, you hardly need to code these algorithms by hand when it comes to writing real code. The Programming language you will use already have tried and tested implementation for those algorithms and that's what you will learn in this article. In Java Programming language, it's easy to sort an array, you just need to call the Arrays.sort() method with a Comparator which can sort the array in the order you want but it highly depends upon which type of object is stored in the array.

For example, you can sort an object array in decreasing or reverse order, just provide a Comparator with the opposite order. You can even use Collections.reverseOrder() if you want to sort an 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 bythe  Collection.reverseOrder() method.

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 sorted the array in ascending order and then reverse the array in place as shown here. This is also true for two-dimensional primitive arrays.

Btw, if you are new into Java Programming and not familiar with common Java API and classes like Comparator, Arrays, and Integer then I suggest you to first go through a comprehensive course like The Complete Java Masterclass on Udemy which will teach you all these and much more in quick time. It's also the most up-to-date course in Java.




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 like 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 a Comparator method to sort in the 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 like 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 Java Fundamentals: The Java Language course on Pluralsight to learn more about Java and how to do basic stuff like sorting and searching in Java.


It's an excellent course but you would need a Plurlasight membership to access this course, which cost around $29 per month or $299 per year.  This may seem a bit expensive at first but its well worth because it provides access to more than 5000 online courses on Pluralsight which you can use to learn any latest technology. 

Anyway, even if you don't have Plurlasight membership, you can still access this course for free by signing up for the 10-day FREE Pass which provides 200 minutes of access to all of their courses.




How to sort a Primitive Array in Reverse Order

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

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

This is a 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 on the link.

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 comprehensive course on data structure and algorithms like Data Structures and Algorithms: Deep Dive Using Java to learn more about efficient sorting algorithm like O(n) sorting algorithm like Bucket sort and Counting Sort in Java.

sorting primitive array in descending order in Java





Java Program to Sort an Array in Decreasing Order

Here is a 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.


Further Learning
The Complete Java Masterclass
Data Structures and Algorithms: Deep Dive Using Java
Algorithms and Data Structures - Part 1 and 2
Core Java, Volume 1 11th Edition By Cay S. Horstmann


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)
  • My favorite free courses to learn data Structure in depth (FreeCodeCamp)
  • 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)
  • 100+ Data Structure Coding Problems from Interviews (questions)
  • 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)
  • 50+ Data Structure and Algorithms Problems from Interviews (questions)
  • Iterative PreOrder traversal in a binary tree (solution)
  • How to count the number of leaf nodes in a given binary tree in Java? (solution)
  • 10 Free Data Structure and Algorithm Courses for Programmers (courses)
  • 10 Free Courses to Learn Java Programming (courses)
Thanks for reading this article so far. If you like this Java Array tutorial then please share with your friends and colleagues. If you have any questions or feedback then please drop a comment.


P. S. - If you are looking for some Free Algorithms courses to improve your understanding of Data Structure and Algorithms, then you should also check the Easy to Advanced Data Structures course on Udemy. It's authored by a Google Software Engineer and Algorithm expert and its completely free of cost.

4 comments:

  1. Thanks for this info but you have a bug in your reverse() routine.

    for (int i = 0; i <= middle; i++) {

    That should be i < middle.

    Otherwise you swap the middle two items twice when the length is even.

    ReplyDelete
  2. Arrays.sort(squares, Collections.reverseOrder()); - this does not work

    ReplyDelete