Sorting Program in Java
Sorting Program in Java: The sorting program in Java is used to sort arrays either in ascending or descending order. There are two predefined methods available in Java that are used to sort the arrays/ lists. One is Arrays.sort() and another is Collections.sort(). Let’s discuss one by one.
Arrays.sort(): Arrays.sort() works very well with arrays which can be of a primitive data type.
Filename: SortingExample.java
// Importing class Arrays of the sub-package util.
import java.util.Arrays;
public class SortingExample
{
public static void main(String argvs[])
{
// String array
String[] str = { "hjk", "ty", "trf", "tyf", "ytf", "bnm", "uio", "oml", "tkt" };
// Integer Array
int[] intAr = { 31, 5, 86, 405, 211, 19, 171, 192, 67 };
Arrays.sort(str); // Sorting string array
Arrays.sort(intAr); // Sorting integer array
// Displaying results
System.out.printf("Sorted str[] : %s \n", Arrays.toString(str));
System.out.printf("Modified intAr[] : %s", Arrays.toString(intAr));
}
}
Output:
Sorted str[] : [bnm, hjk, oml, tkt, trf, ty, tyf, uio, ytf] Modified intAr[] : [5, 19, 31, 67, 86, 171, 192, 211, 405]
Explanation: The sort() method is the static method that is present in the Arrays class which in turn is part of the java.util sub-package. Therefore, only the class name will sufficient to invoke the sort() method. The sort() method can also be used to sort subarrays. The following example illustrates the same.
Filename: SortingExample1.java
// Importing class Arrays of the sub-package util.
import java.util.Arrays;
public class SortingExample1
{
public static void main(String argvs[])
{
// String array
String[] str = { "hjk", "ty", "trf", "tyf", "ytf", "bnm", "uio", "oml", "tkt" };
// Integer Array
int[] intAr = { 31, 5, 86, 405, 211, 19, 171, 192, 67 };
// Sorting string sub-array of size 8 starting from 0th index
Arrays.sort(str, 0, 8);
//Sorting integer sub-array of size 7 starting from 0th index
Arrays.sort(intAr, 0, 7);
// Displaying results
System.out.printf("Sorted str[] : %s \n", Arrays.toString(str));
System.out.printf("Modified intAr[] : %s", Arrays.toString(intAr));
}
}
Output:
Sorted str[] : [bnm, hjk, oml, trf, ty, tyf, uio, ytf, tkt] Modified intAr[] : [5, 19, 31, 86, 171, 211, 405, 192, 67]
Explanation: In the above program, we have used the sort() method, which takes three arguments. The first argument is the array, and the second and the third arguments are the starting and ending index of the sub-array. The element presented at the ending index is not included in sorting. However, the starting index element takes part in sorting. Therefore, the above program performs sorting from 0th index to 7th index in the String array, and from 0th to 6th index for the int array.
Sorting in Descending Order in Arrays
By default, sorting is done in ascending order. However, we can do sorting in descending order. Consider the following example.
Filename: SortingExample2.java
// Importing classes Arrays and Collections of the sub-package util.
import java.util.Arrays;
import java.util.Collections;
public class SortingExample2
{
public static void main(String argvs[])
{
// String array
String[] str = { "hjk", "ty", "trf", "tyf", "ytf", "bnm", "uio", "oml", "tkt" };
// Integer Array
Integer[] intAr = { 31, 5, 86, 405, 211, 19, 171, 192, 67 };
// Sorting string sub-array of size 8 starting from 0th index in descending order
Arrays.sort(str, 0, 8, Collections.reverseOrder());
//Sorting integer sub-array of size 7 starting from 0th index in descending order
Arrays.sort(intAr, 0, 7, Collections.reverseOrder());
// Displaying results
System.out.printf("Sorted str[] : %s \n", Arrays.toString(str));
System.out.printf("Modified intAr[] : %s", Arrays.toString(intAr));
}
}
Output:
Sorted str[] : [ytf, uio, tyf, ty, trf, oml, hjk, bnm, tkt] Modified intAr[] : [405, 211, 171, 86, 31, 19, 5, 192, 67]
Explanation: The reverseOrder() method does the trick here. It is a static method of the Collections class. Note that instead of int, we have used Integer in the above program. Because the reverseOrder() method deals with objects, and objects are only created of a class like Integer, not of a data type like int.
Collections.sort(): TheCollections.sort() method is mainly used for object Collections like LinkedList or ArrayList.
Filename: SortingExample3.java
// Importing classes ArrayList and Collections of the sub-package util.
import java.util.ArrayList;
import java.util.Collections;
public class SortingExample3
{
public static void main(String argvs[])
{
// Creating an ArrayList of strings
ArrayList<String> arLi = new ArrayList<String>();
// Adding elements to the list
arLi.add("Kritesh");
arLi.add("Suresh");
arLi.add("Mahesh");
arLi.add("Jignesh");
arLi.add("Nilesh");
arLi.add("Yogesh");
arLi.add("Sumesh");
arLi.add("Gitesh");
arLi.add("Priyesh");
// Sorting the list
Collections.sort(arLi);
// Displaying results
System.out.printf("Modified list after the effect of Collections.sort(): \n" + arLi);
}
}
Output:
Modified list after the effect of Collections.sort(): [Gitesh, Jignesh, Kritesh, Mahesh, Nilesh, Priyesh, Sumesh, Suresh, Yogesh]
Explanation: Since it is a list, Arrays.sort() method will not work here. Similar to Arrays.sort() method, default style of sorting in Collections.sort() is also in ascending order. We can also sort the given list partially. The following example illustrates the same.
Filename: SortingExample3.java
// Importing classes ArrayList and Collections of the sub-package util.
import java.util.ArrayList;
import java.util.Collections;
public class SortingExample3
{
public static void main(String argvs[])
{
// Creating an ArrayList of strings
ArrayList<String> arLi = new ArrayList<String>();
// Adding elements to the list
arLi.add("Kritesh");
arLi.add("Suresh");
arLi.add("Mahesh");
arLi.add("Jignesh");
arLi.add("Nilesh");
arLi.add("Yogesh");
arLi.add("Sumesh");
arLi.add("Gitesh");
arLi.add("Priyesh");
// Sorting the list from 0th element to 4th element.
Collections.sort(arLi.subList(0, 5));
// Displaying results
System.out.printf("Modified list after the effect of Collections.sort(): \n" + arLi);
}
}
Output:
Modified list after the effect of Collections.sort(): [Jignesh, Kritesh, Mahesh, Nilesh, Suresh, Yogesh, Sumesh, Gitesh, Priyesh]
Explanation: The subList() method belongs to the ArrayList class. It takes two arguments the first argument accepts the starting index, and the second argument accepts the ending index. The element at the ending index is always excluded in the sorting. Hence, in our case, sorting will take place from 0th position to the 4th one.
Sorting a List in Descending Order
Sorting in descending order in lists is quite similar to arrays. Again, we are using the Collections.reverseOrder() method. Let’s create a Java program that sorts the list in descending order.
Filename: SortingExample4.java
// Importing classes ArrayList and Collections of the sub-package util.
import java.util.ArrayList;
import java.util.Collections;
public class SortingExample4
{
public static void main(String argvs[])
{
// Creating an ArrayList of strings
ArrayList<String> arLi = new ArrayList<String>();
// Adding elements to the list
arLi.add("Kritesh");
arLi.add("Suresh");
arLi.add("Mahesh");
arLi.add("Jignesh");
arLi.add("Nilesh");
arLi.add("Yogesh");
arLi.add("Sumesh");
arLi.add("Gitesh");
arLi.add("Priyesh");
// Sorting in descending order
Collections.sort(arLi, Collections.reverseOrder());
// Displaying results
System.out.printf("Modified list after the effect of Collections.sort(): \n" + arLi);
}
}
Output:
Modified list after the effect of Collections.sort(): [Yogesh, Suresh, Sumesh, Priyesh, Nilesh, Mahesh, Kritesh, Jignesh, Gitesh]
Explanation: Nothing special here! Very much similar to achieve descending order in arrays.
Comparison between Collections.sort() and Arrays.sort()
In the above Java programs, we have used both sort() methods of the classes Collections and Arrays. Let’s discuss what is the difference between them.
We have seen Collections.sort() works well on the lists. However, deep inside Collections.sort() also calls Arrays.sort(). But, before calling Arrays.sort(), Collections.sort() first do the conversion of the input List into an Array then sorting starts.
Thus, Collections.sort() takes one more step as compared to Arrays.sort(). Hence, Collections.sort() is a bit slow as compared to Arrays.sort(). Since Arrays.sort() is called in both the sorting technique, therefore, the sorting algorithm is also the same in both cases. In recent versions of Java, the Timsort algorithm is used for sorting. Timsort is a hybrid sorting algorithm. It is based upon Insertion sort and Merge sort. We will be discussing Merge sort as well as Insertion sort later in detail.