Sorting array is a day-to-day programming task for any software developer.  If you have come from a Computer Science background then you have definitely learned fundamental sorting algorithms like thebubble sort, insertion sort, andquicksort but you don't really need to code those algorithms to sort an array in Java because Java has good support for sorting different types of array. You can useArrays.sort() method to sort both primitive and object array in Java. But, before using this method, let's learn how theArrays.sort() method works in Java. This will not only help you to get familiar with the API but also its inner workings.  This method sorts the given array into ascending order, which is the numeric order for primitives and defined by compareTo() or compare() method for objects.

For primitive arrays, like int,  short, character, float, double orlongarray, this method uses a dual-pivot Quicksort sorting algorithm implemented by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch (author ofEffective Java).

This algorithm offersO(n log(n)) performance on many data sets that cause other quicksort algorithms to degrade into their worst quadratic performance like O(n^2) and is typically faster than traditional (one-pivot) Quicksort implementations.

That's why I always said that prefer the library method on my own, you can get it right but with the amount of testing and user exposure the library method gets, you will never get for your implementations.

On the other hand, the object array is sorted using a stableMergeSort algorithm, which ensures that equal elements keep their original position in the sorted array. Implementation of mergesort used insort(Object[]) is stable, adaptive, and iterative that requires much lesser than O(n log(n)) comparisons when the input array is partially sorted while offering the performance of a traditional mergesort when the input array is randomly ordered.

In the best case, when the input array is almost sorted, this implementation requires approximatelyO(n) comparisons.

By the way, temporary storage requirements vary from a small constant for nearly sorted input arrays ton/2 object references for randomly ordered input arrays. If you are interested in those nitty-gritty algorithms details, you can also join the Data Structures and Algorithms: Deep Dive Using Java course on Udemy. One of the best courses to learn the fundamentals of data structure and algorithms for Java programmers.

7 ways to Sort One and Two Dimensional Array in Java 

In order to sort different types of arrays in Java, you can use any of the overloaded versions of thesort() method from the Arrays class. It also has two special methods for sorting object arrays, one sorts the array in the natural order, while others sort them in a custom order of provided comparator.

Since a two-dimensional array is also an array of an array in Java, you can use this method to sort multidimensional arrays in Java also. You will see step-by-step examples of sorting all kinds of arrays in Java in the subsequent section.

1. Sorting One Dimensional Array in Ascending Order

Sorting any primitive or object array in ascending order is very easy, all you need to know is the sort() method fromjava.util.Arrays class. It provides an overloaded method to sortbyte,short,char,int,long,float,double, and object arrays.

This method sorts the given array in increasing order using two pivot quicksort algorithms. You can use this method to sort an array of objects which implements either the Comparable orComparator method. It has an overloaded version, which accepts a Comparator for custom sorting.

Here is an example to sort anintprimitive array in ascending order in Java.

int[] random= {33,22,11,21,55,32,3,4 };System.out.println("Array before sorting : "+Arrays.toString(random));Arrays.sort(random);System.out.println("Array after sorting in ascending order : "                    +Arrays.toString(random));Output:Array before sorting: [33,22,11,21,55,32,3,4]Array after sorting in ascending order: [3,4,11,21,22,32,33,55]

You can see that array is now sorted in ascending order which was not the case previously. Btw, if you want to learn more about Java API and howComparable andComparator works, I suggest you choose a comprehensive Java course like thesebest Java Programming courses which is also the most up-to-date Java course, recently updated to cover Java 11 features.

2. How to Sort Integer Array in Java

Let's see one more example of the sort() method, this time we will sort an array of Integer objects instead of int primitives. The first line may look similar, but rememberautoboxing will convert eachint value toInteger, but it can not convert an int[] toInteger[].

That's why the sort method used here issort(Object[]) and notsort(int[]), this is also obvious when we sort the Integer array into reverse order and passed areverse order comparator from the Collections class.

Integer[] elevens= {44,22,55,11,33,66,77 };Arrays.sort(elevens);System.out.println("increasing order : "+Arrays.toString(elevens));Arrays.sort(elevens,Collections.reverseOrder());System.out.println("reverse order : "+Arrays.toString(elevens));Output:increasing order: [11,22,33,44,55,66,77]reverse order: [77,66,55,44,33,22,11]

You can see that now the array is sorted in reverse order as 77, the largest number is present at index 0 or at the first position, and 11, the smallest number is at the last index.

3. Sorting String Array in Java - Ascending and Descending Order

A string is not numeric data, it defines its own order which is called lexicographic order, also known as alphabetic order. When yousort an array of String using the sort() method, it sorts an array into natural order defined byComparable interface, as shown below :

3.1 Sorting String Array in Increasing Order

Here is a code example to sort a String array in ascending order in Java. The order is defined by Comparable which the String class implements. Its called lexicographic order, which is similar to alphabetic and alphanumeric order.  

String[] names= {"John","Steve","Shane","Adam","Ben"};System.out.println("String array before sorting : "+Arrays.toString(names));Arrays.sort(names);System.out.println("String array after sorting in ascending order : "                 +Arrays.toString(names));Output:String array before sorting: [John,Steve,Shane,Adam,Ben]String array after sorting in ascending order: [Adam,Ben,John,Shane,Steve]

3.2 Sorting String Array in Decreasing Order

Now, let's the example to sort a string array in the descending order. This is just online line change. I have added Collections.soreverOrder() to ever the sorting order for arrays. 

Arrays.sort(names,0, names.length,Collections.reverseOrder());System.out.println("String array after sorting in descending order : "                +Arrays.toString(names));Output:String array after sorting in descending order: [Steve,Shane,John,Ben,Adam]

You can see that String is now sorted in lexicographic order which is a combination of alphabetic and alphanumeric order. If you want to learn more about String in Java, please see The Complete Java MasterClass course on Udemy.

4. Sorting Object Array in Java

In order to sort an object array, all elements must implement either a Comparable orComparator interface to define an order. You can use either usesort(Object[]) method to sort an object array in its natural order, you must ensure that all elements in the array must implementComparable.

Furthermore, they must be mutually comparable as well, for example,e1.compareTo(e2) must not throw aClassCastException for any elements e1 and e2 in the array.

Alternatively, you can sort an Object array on custom order using the sort(T[], Comparator) method. as shown in the following example.

// How to Sort Object Array in Java using Comparator and ComparableCourse[] courses=newCourse[4];courses[0]=newCourse(101,"Java",200);courses[1]=newCourse(201,"Ruby",300);courses[2]=newCourse(301,"Python",400);courses[3]=newCourse(401,"Scala",500);System.out.println("Object array before sorting : "                     +Arrays.toString(courses));Arrays.sort(courses);System.out.println("Object array after sorting in natural order : "                     +Arrays.toString(courses));Arrays.sort(courses,newCourse.PriceComparator());System.out.println("Object array after sorting by price : "                     +Arrays.toString(courses));Arrays.sort(courses,newCourse.NameComparator());System.out.println("Object array after sorting by name : "+Arrays.toString(courses));Output:Object array before sorting: [#101Java@200 , #201Ruby@300 , #301Python@400 , #401Scala@500 ]Object array after sorting in natural order: [#101Java@200 , #201Ruby@300 ,  #301Python@400 , #401Scala@500 ]Object array after sorting by price: [#101Java@200 , #201Ruby@300 ,   #301Python@400 , #401Scala@500 ]Object array after sorting by name: [#101Java@200 , #301Python@400 ,  #201Ruby@300 , #401Scala@500 ]

5. How to sort Array in Reverse order in Java

Sorting an object array in descending order is easy because Java API provides asort() method which takes botharray andComparator, which can be used to sort array in reverse order.

For example, you can sort a String array in reverse order by using the Collections.reverseComparator() method, which is a built-in reverse comparator from the Collections utility class.

You can sort all numeric arrays e.g.Integer,Double orFloat using the same technique. But, when it comes tosorting a primitive array in reverse order, you are left with nothing. You can not sort a primitive array with a reverse comparator and Java doesn't provide a direct method for sorting in descending order.

You can do two things, write your own method using any efficient sorting algorithm like quicksort, sort the array in descending order, or just sort the array using the Arrays.sort() method and reverse it.

Former can be a clean approach but you would likely be going to get efficiency which comes with a library method likeArrays.sort(), which is a double pivot quicksort implementation and offersO(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance.

The second approach is better but will cost you an additionalO(n) performance. There is one more way, going via the Collection route, you canconvert the array to list and sort the list in reverse order, but you will not get any performance benefit.

6. How to Sort Two dimensional Array in Java? Examples

There is no easy way tosort a multi-dimensional array in Java, Java API provides no direct method to sort a two or three-dimensional array, maybe because it's not clear how do you want to sort a multi-dimensional array.

If you want to sort your two-dimensional array on columns then you can use ourColumnComparator class which implements a Comparator interface to sort column data. You can see the full code of this class in our program section. It also usesJava enum to define sorting orders like ASCENDING andDESCENDING, which is much better than a blank boolean variable.

In the following examples, we first sort a two-dimensional array in ascending order on the first column, while in the second example we sort it on increasing order but this time only the second column.

If you want to sort all columns of a multidimensional array, you can just extend this program toiterate over an array, and passing column index toColumnCompartor.

6.1 Sorting Array in Ascending Order on the first Column

This is the code example to sort a two-dimension array in the ascending order of the first column. This is also the standard way to sort a 2D array in Java and it's also more common than sorting array on the second column which we will see in the next example. 

Integer[][] numbers= { {9,6,5}, {3,2,4}, {1,5,7} };System.out.println("Two dimensional array before sorting : "                +Arrays.deepToString(numbers));Arrays.sort(numbers,newColumnComparator(0,SortingOrder.ASCENDING));System.out.println("2D array after sorting in ascending order on first column : "+Arrays.deepToString(numbers));OutputTwo dimensional array before sorting: [[9,6,5], [3,2,4], [1,5,7]]2D array after sorting in ascending order on first column:                [[1,5,7], [3,2,4], [9,6,5]]

6.2 Sorting Array in Ascending Order on Second Column

Here is a code example to sort a two-dimensional array in ascending order of the second column in Java. This is a rare case but if you are implementing real-world applications you will face this kind of scenario where you need to sort a 2D array on secondary data. 

Arrays.sort(numbers,newColumnComparator(1,SortingOrder.DESCENDING));System.out.println("Sorting two dimensional String array in Java,        Second column, Ascending order : "+Arrays.deepToString(numbers));OutputSorting two dimensionalString array inJava,Second column,      Ascending order: [[9,6,5], [1,5,7], [3,2,4]]

7. Java Program to Sort Array in Java

Here is our complete Java program, which you can just copy-paste and run in Eclipse by right click. Alternatively, you can copy the source in a text file with the name same as the main class, compile it using the javac command and run it by using the java command directly from the command prompt.

This contains code to sort a primitive array on increasing order, sorting integer and string array in ascending and descending order, sorting object arrays, andsorting 2D array columns.

If you have any questions or face any problems while running this sample program, please let us know.

importjava.util.Arrays;importjava.util.Collections;importjava.util.Comparator;/** * Couple of examples of Multi-dimensional array in Java. It shows how to * declare multidimensional array in Java, how to initialise them both inline * and using for loop and how to access particular elements from two dimensional * array. * *@author Javin Paul */publicclass ArraySorter {publicstaticvoidmain(String args[]) {// How to sort Integer array in Java - ascending orderint[] random= {33,22,11,21,55,32,3,4 };System.out.println("Array before sorting : "+Arrays.toString(random));Arrays.sort(random);// sorts primitive array using quicksort algorithmSystem.out.println("Array after sorting in ascending order : "+Arrays.toString(random));// How to sort String array in JavaString[] names= {"John","Steve","Shane","Adam","Ben"};System.out.println("String array before sorting : "+Arrays.toString(names));Arrays.sort(names);// sorts object array using mergesort algorithmSystem.out.println("String array after sorting in ascending order : "+Arrays.toString(names));// How to sort String array in descending order in JavaArrays.sort(names,0, names.length,Collections.reverseOrder());System.out.println("String array after sorting in descending order : "+Arrays.toString(names));// How to Sort Object Array in Java using Comparator and ComparableCourse[] courses=newCourse[4];        courses[0]=newCourse(101,"Java",200);        courses[1]=newCourse(201,"Ruby",300);        courses[2]=newCourse(301,"Python",400);        courses[3]=newCourse(401,"Scala",500);System.out.println("Object array before sorting : "+Arrays.toString(courses));Arrays.sort(courses);System.out.println("Object array after sorting in natural order : "                                 +Arrays.toString(courses));Arrays.sort(courses,newCourse.PriceComparator());System.out.println("Object array after sorting by price : "+Arrays.toString(courses));Arrays.sort(courses,newCourse.NameComparator());System.out.println("Object array after sorting by name : "                                      +Arrays.toString(courses));// How to sort two dimensional array in Java on first column, increasing orderInteger[][] numbers= { {9,6,5}, {3,2,4}, {1,5,7} };System.out.println("Two dimensional array before sorting : "                                          +Arrays.deepToString(numbers));Arrays.sort(numbers,newColumnComparator(0,SortingOrder.ASCENDING));System.out.println("2D array after sorting                             in ascending order on first column : "+Arrays.deepToString(numbers));// sorting 2D array on second column in descending orderArrays.sort(numbers,newColumnComparator(1,SortingOrder.DESCENDING));System.out.println("Sorting two dimensional String array in Java,                    Second column, Ascending order : "+Arrays.deepToString(numbers));    }}/* * Simple Enum to represent sorting order e.g. ascending and descending order */enum SortingOrder{    ASCENDING, DESCENDING;};/* * Utility Comparator class to sort two dimensional array in Java */class ColumnComparatorimplements Comparator<Comparable[]> {privatefinalint iColumn;privatefinalSortingOrder order;publicColumnComparator(int column,SortingOrder order) {        this.iColumn= column;        this.order= order;    }@Overridepublicintcompare(Comparable[] c1,Comparable[] c2) {int result= c1[iColumn].compareTo(c2[iColumn]);return order==SortingOrder.ASCENDING? result:-result;    }}class Courseimplements Comparable<Course>{int id;String name;int price;publicCourse(int id,String name,int price){        this.id= id;        this.name= name;        this.price= price;    }@OverridepublicintcompareTo(Course c) {return this.id- c.id;    }@OverridepublicStringtoString() {returnString.format("#%d %s@%d ", id, name, price);    }publicstaticclass PriceComparatorimplements Comparator<Course>{@Overridepublicintcompare(Course c1,Course c2) {return c1.price- c2.price;        }           }publicstaticclass NameComparatorimplements Comparator<Course>{@Overridepublicintcompare(Course c1,Course c2) {return c1.name.compareTo(c2.name);        }    }   }

That's all abouthow to sort an array in Java. We have learned to sort both primitive and object arrays in both ascending and descending order. The only piece which is a bit tricky is sorting primitive arrays in reverse order because there is no direct method to do that in Java.

You need to go through steps like first sorting them in increasing order and then reversing or writing your method to do the job or converting an array to a list and vice-versa. In any case, use a library method to do sorting for performance and robustness, as you know-how using a two pivot quicksort method on the Arrayssort() method gives better performance for arrays for which other similar sorting algorithms result in O(n^2).

Autoboxing cannot help to convert anint[] toInteger[] so there is no shortcut also.Prefer List over array due to this reason but for performance-critical code use a primitive array to save memory and reduce GC cost.