Java Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we'll discuss common methods to sort arrays in ascending and descending order.

We'll look at using Java's Arrays class sorting method as well as implementing our own Comparator to order our arrays' values.

2. Object Definitions

Before we begin, let's quickly define a few arrays that we'll sort throughout this tutorial. First, we'll create an array of ints and an array of strings:

int[] numbers = new int[] { -8, 7, 5, 9, 10, -2, 3 };
String[] strings = new String[] { "learning", "java", "with", "baeldung" };

And let's also create an array of Employee objects where each employee has an id and a name attribute:

Employee john = new Employee(6, "John");
Employee mary = new Employee(3, "Mary");
Employee david = new Employee(4, "David");
Employee[] employees = new Employee[] { john, mary, david };

3. Sorting in Ascending Order

Java's util.Arrays.sort method provides us with a quick and simple way to sort an array of primitives or objects that implement the Comparable interface in ascending order.

When sorting primitives, the Arrays.sort method uses a Dual-Pivot implementation of Quicksort. However, when sorting objects an iterative implementation of MergeSort is used.

3.1. Primitives

To sort a primitive array in ascending order, we pass our array to the sort method:

Arrays.sort(numbers);
assertArrayEquals(new int[] { -8, -2, 3, 5, 7, 9, 10 }, numbers);

3.2. Objects That Implement Comparable

For objects that implement the Comparable interface, as with our primitive array, we can also simply pass our array to the sort method:

Arrays.sort(strings);
assertArrayEquals(new String[] { "baeldung", "java", "learning", "with" }, strings);

3.3. Objects That Don't Implement Comparable

Sorting objects that don't implement the Comparable Interface, like our array of Employees, requires us to specify our own comparator.

We can do this very easily in Java 8 by specifying the property that we would like to compare our Employee objects on within our Comparator:

Arrays.sort(employees, Comparator.comparing(Employee::getName));
assertArrayEquals(new Employee[] { david, john, mary }, employees);

In this case, we've specified that we would like to order our employees by their name attributes.

We can also sort our objects on more that one attribute by chaining our comparisons using Comparator's thenComparing method:

Arrays.sort(employees, Comparator.comparing(Employee::getName).thenComparing(Employee::getId));

4. Sorting in Descending Order

4.1. Primitives

Sorting a primitive array in descending order is not quite as simple as sorting it in ascending order because Java doesn't support the use of Comparators on primitive types. To overcome this shortfall we have a few options.

First, we could sort our array in ascending order and then do an in-place reversal of the array.

Second, could convert our array to a list, use Guava's Lists.reverse() method and then convert our list back into an array.

Finally, we could transform our array to a Stream and then map it back to an int array. It has a nice advantage of being a one-liner and just using core Java:

numbers = IntStream.of(numbers).boxed().sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();
assertArrayEquals(new int[] { 10, 9, 7, 5, 3, -2, -8 }, numbers);

The reason this works is that boxed turns each int into an Integer, which does implement Comparator.

4.2. Objects That Implement Comparable

Sorting an object array that implements the Comparable interface in descending order is quite simple. All we need to do is pass a Comparator as the second parameter of our sort method.

In Java 8 we can use Comparator.reverseOrder() to indicate that we would like our array to be sorted in descending order:

Arrays.sort(strings, Comparator.reverseOrder());
assertArrayEquals(new String[] { "with", "learning", "java", "baeldung" }, strings);

4.3. Objects That Don't Implement Comparable

Similarly to sorting objects that implement comparable, we can reverse the order of our custom Comparator by adding reversed() at the end of our comparison definition:

Arrays.sort(employees, Comparator.comparing(Employee::getName).reversed());
assertArrayEquals(new Employee[] { mary, john, david }, employees);

5. Conclusion

In this article, we discussed how to sort arrays of primitives and objects in ascending and descending order using the Arrays.sort method.

As usual, the source code from this article can be found over on Github.

Java bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE
Comments are closed on this article!