Saturday, July 10, 2021

How to Sort an Array in Java? Ascending and Descending Order of Elements Example

Quite often we need to sort array in Java luckily java.util.Arrays class provides several utility methods to sort java array of any type e.g. primitive, object or int, String, etc. Arrays are in java.util package and exposed all sorting related methods as static utility functions. you can access sort() as Arrays.sort() and just pass your array and it will sort that array object. You can sort arrays in ascending order, descending order, or any custom order defined by the custom comparator in Java.


In the last article, we have seen how to Sort ArrayList in Java and in this Java article we will see examples of sorting array in ascending order, descending order, and sorting sub-arrays in java.

By the way, basic knowledge of essential data structure is also very important and that's why I suggest all Java programmers join this comprehensive Data Structure and Algorithms online courses to fill the gaps in your understanding.



Sort Array in Java on ascending and descending order

Sorting Java Array into Ascending Order:

how to sort array in java ascending descending order exampleIn order to sort an array (String, int, or any type) in ascending order we don't need anything special. Arrays.sort() method by default sort elements in their natural order implemented by the CompareTo method. The string array in Java will be sorted lexicographically

The integer will be sorted numerically in ascending order. look on the code section for a complete example of how to sort java array into ascending order. You can also sort anonymous arrays in Java by this method but since you don’t have any name to refer that it doesn’t make much sense.



1. Sorting Java Array into Descending Order:

In order to sort a java array into descending order, you need to provide an external Comparator in Java which can sort elements in there reverse order, and luckily we have that built int as java.util.Collections.reverseOrder(), which returns a reverse order comparator that gives reverse of natural ordering of element objects. pass this reverse comparator to the sort method and it will sort an array into descending order as shown in the code example in the last section. 

There is another way in which you can convert Array into ArrayList and then sort the ArrayList but that’s again a two-step process so it's better to sort an array using Arrays.sort() method



2. Sorting Sub Array in Java

Arrays class also provides methods to sort part of java array or sub-array. So in case if you have a big array and you only need to sort a particular section then just provide the start index and end index to java.util.Arrays.sort(array,index,index) and it will sort the array only for that range. 

This is much faster than sorting the whole array and then getting a range of values out of it. 

Here is a code example of sorting part of the array in Java:


3. Code Example of Sorting Array in Java

In this section of code example we will see how to sort Java array into ascending order, descending order, and sorting sub-arrays in Java:


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

public class HashtableDemo {

public static void main(String args[]) {
String[] companies = { "Google", "Apple", "Sony" };

// sorting java array in ascending order
System.out.println("Sorting String Array in Ascending order in Java Example");
System.out.println("Unsorted String Array in Java: ");
printNumbers(companies);
Arrays.sort(companies);
System.out.println("Sorted String Array in ascending order : ");
printNumbers(companies);

// sorting java array in descending order
System.out.println("Sorting Array in Descending order in Java Example");
System.out.println("Unsorted int Array in Java: ");
printNumbers(companies);
Arrays.sort(companies, Collections.reverseOrder());
System.out.println("Sorted int Array in descending order : ");
printNumbers(companies);

System.out.println("Sorting part of array in java:");
int[] numbers = { 1, 3, 2, 5, 4 };
Arrays.sort(numbers, 0, 3);
System.out.println("Sorted sub array in Java: ");
for (int num : numbers) {
System.out.println(num);
}

}

public static void printNumbers(String[] companies) {
for (String company : companies) {
System.out.println(company);
}
}

}

Output:
Sorting String Array in Ascending order in Java Example
Unsorted String Array in Java:
Google
Apple
Sony

Sorted String Array in ascending order :
Apple
Google
Sony

Sorting Array in Descending order in Java Example
Unsorted int Array in Java:
Apple
Google
Sony
Sorted String Array in descending order :
Sony
Google
Apple
Sorting part of array in java:
Sorted sub array in Java:
1
2
3
5
4



Important points about the Sort method of Arrays:

Here is some important and worth noting point about sort method of Arrays class for quick references:

1. Arrays.sort() is an overloaded method and can sort int, byte, short, char or object[] arrays.

2. Arrays.sort)( also allows you to sort a sub-array or part of the array in Java.

3. Arrays class also contains utility methods e.g. binarySearch for performing a search on array

That’s all on how to sort java array in ascending and descending order and part of the array in Java. You can also use the workaround by converting an array into ArrayList and then sorting but I think Arrays.sort() is the preferred method for sorting arrays in Java.


Java Tutorials you may like

8 comments :

Unknown said...

int minval = input[0];
int temp=0;
for(int i = 0; i< input.length; i++)
{
for(int j = 0; j< input.length-1; j++)
{
if(input[j+1]<input[j])
{
temp=input[j+1];
input[j+1]=input[j];
input[j]=temp;
}
}
}

Anonymous said...

One of the most important thing to know about Arrays.sort() method is that it uses two pivot quicksort algorithm to sort primitives while a stable mergesort algorithm to sort objects. In addition, there is one more overloaded version of sort(array, Comparator) which takes comparator to sort array in custom order, and can be uesd to sort in reverse order. By the way, sorry to say but no easy way to sort primitive in reverse order.

Anonymous said...

There are couple of other ways to sort array in Java e.g. by using bubble sort, quick sort or insertion sort. Though Java only support quicksort via java.util.Arrays class, you can still write this sorting algorithm code by your own.

Unknown said...

hi please help me if i am using
Arrays.sort(numbers, 0, numbers.length-1, Collections.reverseOrder());

it is saying this argument is not applicable



public static Comparator reverseOrder(Comparator cmp) {
if (cmp == null)
return reverseOrder();

if (cmp instanceof ReverseComparator2)
return ((ReverseComparator2)cmp).cmp;

return new ReverseComparator2<>(cmp);
}

javin paul said...

Hello Shailesh, what is the type of numbers array? if it's a primitive array e.g. an int array then it will not work because Array.sort() method accepts array of objects e.g. Integer, String or Short. This limitation because Comparator can only compare objects.

int[] numbers = {1, 2, 3};
Arrays.sort(numbers, 0, numbers.length-1, Collections.reverseOrder()); // not ok

Integer[] primes = {2, 3};
Arrays.sort(primes, 0, primes.length-1, Collections.reverseOrder()); // Ok

Anonymous said...

Unfortunately, there is no way to sort a primitive array in reverse or descending order by using Array.sort() method. Only reasonable way is to sort the array in ascending order and then reverse the array in place as shown in that article.

Unknown said...

CMD could not found or load main class
where i was mistake please check
import java.util.Scanner;
class Ascending_Order
{
public static void main(String args[])
{
int n, temp;
Scanner s = new Scanner(System.in);
System.out.print("Enter no. of elements you want in array:6");
n = s.nextInt();
int a[] = new int[6];
for (int i=0; i<6;i++)
{
a[i] = s.nextInt();
}
for (int i=0;i<6;i++)
{
for (int j=i+1;j<6;j++)
{
if (a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
System.out.print("all elements in Ascending Order:");
for (int i=0; i<6-1;i++)
{
System.out.print(a[i]+",");
}
System.out.print(a[6-1]);
}
}

Maria Khan said...

Hy guys here is the program of sort ascending and descending without the sort method:





import java.util.Scanner;

public class Experiment
{
public static void main(String args[])
{
Scanner scan = new Scanner(System.in);
int tenNums[]=new int[10], orderedNums[]=new int[10];
int greater;
String choice;

//get input
System.out.println("Enter 10 integers : ");
for (int i=0;i ");
tenNums[i] = scan.nextInt();
}
System.out.println();

//imperfect number ordering algorithm
for(int indexL=0;indexLtenNums[indexR])
{
greater++;
}
}
orderedNums[greater]=tenNums[indexL];
}

//ask if ascending or descending
System.out.print("Display order :\nA - Ascending\nD - Descending\nEnter your choice : ");
choice = scan.next();

//output the numbers based on choice
if(choice.equalsIgnoreCase("a"))
{
for(greater=0;greater-1;greater--)
{
System.out.print(orderedNums[greater]+" ");
}
}
}
}

Post a Comment