Ways to Perform Sorting in Java

Java has a built-in method for sorting the elements in collections like ArrayLists, LinkedList etc.

The arrays class also has a built-in method “sort” that enables sorting the arrays only.

You may sort the elements of arrays or collections in ascending or descending order.

In this tutorial, I will show you how to use the Java array sort method along with java.util.collections.sort method for ArrayList and other collections and bubbleSort algorithm(in the last section), so keep reading.

Java array sort method

First, let me start with the array sort method. You may skip to the next section to learn about the Collections sort method.

• The method for sorting arrays belongs to java.util.Arrays.sort().
• The sort method of arrays does not return any value but simply sorts the given array in ascending order.
• You may use the sort method of arrays for sorting the numeric or string arrays.

Syntax of using the sort method in Arrays

Following is the general syntax of using the sort method of arrays class:

In this way, the given array elements will be sorted into ascending numerical order. The method returns no value.

You may also specify the selection of elements to sort in the given array as follows:

public static void sort(array,

        int fromIndex,

        int toIndex)

An example of sorting an int array

For sorting arrays demo, an array of int elements is created in random order.

After that, the sort Java method is used for sorting the elements in ascending order.

To see the difference, the array elements before and after using the sort method are displayed:

import java.util.Arrays;

public class sort_demo {

           public static void main(String[] args) {
               int[] arr_int = {5,3,7,1,11,9};

               System.out.println("Array before sorting: " + Arrays.toString(arr_int)+"\n");

               Arrays.sort(arr_int);

               System.out.println("Array after sorting: " + Arrays.toString(arr_int));

           }

}

Output:

An example of sorting elements in descending order

For sorting the arrays in descending order you may use the arrays.sort() method with the Collections.reverseOrder() method.

However, the reverseOrder() method works with objects only. So, if you have a primitive type array like in the above example, it will not work.

For this example, an array of Integer type is created that contains random numbers. After that, sort method with reverseOrder() is used for sorting in descending order:

import java.util.Arrays;

import java.util.Collections;

public class sort_demo {

    public static void main(String[] args) {

      Integer[] arr_integer = {55,11,44,99,60,65};
        System.out.println("Array before sorting: " + Arrays.toString(arr_integer)+"\n");

        Arrays.sort(arr_integer, Collections.reverseOrder());
        System.out.println("Array in DESC order: " + Arrays.toString(arr_integer));

     }

}

Output:

Sort a string array example

Similarly, you may sort a string array that contains string elements in random order. For sorting a string array example, I created an array with alphabets in random order.

The Java array sort method is used twice:

• First for sorting string elements in ascending order
• The second uses Collections.reverseOrder() method with sort() for descending order

Have a look:

import java.util.Arrays;

import java.util.Collections;

public class sort_demo {

   public static void main(String[] args)

      {

       String arr_string[] = {"c","d", "a", "e","k","z", "l", "b"};

        System.out.println("Original string array: " + Arrays.toString(arr_string)+"\n");              

         //sort in ASC order

         Arrays.sort(arr_string);

         System.out.println("String array in Asc: " + Arrays.toString(arr_string)+"\n");

         //sort in DESC order

         Arrays.sort(arr_string, Collections.reverseOrder());
         System.out.println("String Array in DESC order: " + Arrays.toString(arr_string));
      }
}

Output:

Sorting a selection of array elements example

As mentioned earlier, the array sort method also allows sorting the given range of array elements.

For example, you only need to sort the elements from 3 to 7 index positions.

import java.util.Arrays;

public class sort_demo {

  public static void main(String[] args) {
    int[] arr_int = {15,13,17,11,19,21, 3, 7, 5};

     System.out.println("Original int array: " + Arrays.toString(arr_int)+"\n");
     Arrays.sort(arr_int,2,7);

     System.out.println("Array range sorting: " + Arrays.toString(arr_int));

  }

}

The output of above code is:

You can see, the elements 0 and 1 remained in the same place even after using the sort() method.

The sorting started at index 2 and ended at 6 position. The reason is endindex parameter does not include the given number.

A simple solution for primitive type descending order

As mentioned earlier, the primitive type array cannot be sorted in descending order by using the Collections.reverseOrder() method.

You may develop your own algorithm or use some other class by a third party if this is required.

Following is a simple solution that you may use for primitive type array in descending order.

import java.util.Arrays;

public class sort_demo {

   public static void main(String[] args) {
      int[] arr_int = {7,3,13,15,5,21,-1};

      System.out.println("Array before sorting: " + Arrays.toString(arr_int)+"\n");

      Arrays.sort(arr_int);

      System.out.println("Array after sorting: " + Arrays.toString(arr_int)+"\n");
      System.out.println("In descending order:");

        for(int i=arr_int.length-1; i>=0; i--) {
          System.out.println(arr_int[i]);
        }
     }
}

The output of this program:

You see, the int array is displayed in the original order, in ascending order by using sort() method and finally in descending order.

Java Collections sort method

Now, let us explore the Collections sort method that enables list sort like ArrayList, LinkedList, etc.

The array sort method allows sorting only the elements of the array. However, you may use the Collections sort method for sorting different collections.

Syntax of using the Collections sort method

Following is the syntax for using the Collections.sort method:

Where:

You may also use list sort method as follows:

In this way, the list is sorted based on the specified comparator.

An example of sorting ArrayList items

For demonstrating the sort method of Collections, an ArrayList of 5 elements that are vowel letters is created in random order.

After that, the sort method is used for ordering it in ascending order as follows:

import java.util.*;

public class sort_demo {

  public static void main(String[] args) {
    ArrayList<String> vowel_list_sort = new ArrayList<String>(); //Declaring vowel ArrayList
     vowel_list_sort.add("a");

     vowel_list_sort.add("u");

     vowel_list_sort.add("o");

     vowel_list_sort.add("e");

     vowel_list_sort.add("i");
       //Displaying ArrayList

       System.out.println("Before List sort" +vowel_list_sort+"\n");
       //Sorting List

       Collections.sort(vowel_list_sort);

       System.out.println("After List sort" +vowel_list_sort);

    }

}

You can see the difference before and after using the sort method.

Example of Integer Array List sorting

For this example, the ArrayList of Integer objects is created in random order. The List is displayed before and after using the sort Collections method:

import java.util.*;

public class sort_demo {

   public static void main(String[] args) {

   ArrayList<Integer> ranList = new ArrayList<Integer>(); //Declaring ArrayList

    ranList.add(75);
    ranList.add(11);
    ranList.add(39);
    ranList.add(7);

   //Displaying ArrayList

    System.out.println("Before ArrayList sort " +ranList+"\n");

   //Sorting ArrayList

    Collections.sort(ranList);

   System.out.println("After ArrayList sort " +ranList);

 }

}

Output:

Sorting string ArrayList in descending order example

The sorting of the list is done in ascending order as using the sort method.

If you require getting the list in descending order then you may use the reverseOrder() method of Collections.

The following example shows a string list sorted in descending order:

import java.util.*;
public class sort_demo {

  public static void main(String[] args) {
    ArrayList<String> vow_list = new ArrayList<String>(); //Declaring vowel ArrayList

    vow_list.add("a");
    vow_list.add("u");
    vow_list.add("o");
    vow_list.add("e");
    vow_list.add("i");

    //Displaying ArrayList

      System.out.println("Original List " +vow_list+"\n");

    //Sorting List

      Collections.sort(vow_list);

      System.out.println("Sorted list in Ascending Order " +vow_list +"\n");

    //In desc order

      Collections.sort(vow_list, Collections.reverseOrder());

      System.out.println("Sorted list in Descending Order " +vow_list);

  }

}

The output of above example is:

Did you notice, this is the other way of using the Java Collections.sort method described in the syntax section? That is:

Collections.sort(List<T> list, Comparator<? super T> c)

Using  Collections reverse method for descending order

You may also use the reverse method of Collections for sorting the list in descending order. This is how you may use it:

See an example below for making things clearer:

import java.util.*;

public class sort_demo {

  public static void main(String[] args) {

   ArrayList<Integer> intList = new ArrayList<Integer>(); //Declaring ArrayList

    intList.add(20);
    intList.add(5);
    intList.add(10);
    intList.add(25);
    intList.add(15);

    //Displaying ArrayList

      System.out.println("Original List " +intList+"\n");

    //Sorting List

      Collections.sort(intList);

      System.out.println("Sorted Integer list in Ascending Order " +intList +"\n");
    //In desc order

      Collections.reverse(intList);

      System.out.println("Sorted Integer list in Descending Order " +intList);

   }
}

The output:

Is not that even cool?

Using bubble sort Algorithm for sorting arrays

You may also use the Bubble sort algo for sorting the arrays.

See the following example where you can see Bubble sort algorithm code along with an example array that is passed for sorting.

import java.util.*;

public class sort_demo { 

    static void bubbleSort(int[] arr_sort) { 

        int num = arr_sort.length; 

        int z = 0; 

         for(int x=0; x < num; x++){ 

           for(int y=1; y < (num-x); y++){ 

              if(arr_sort[y-1] > arr_sort[y]){ 

                z = arr_sort[y-1]; 

                arr_sort[y-1] = arr_sort[y]; 

                arr_sort[y] = z; 

               } 

             } 

        } 

    }

         public static void main(String[] args) { 

               int[] arr_int = {47,13,9,19,5,1,-1,-11};

               System.out.println("Array before Bubble sorting: " + Arrays.toString(arr_int)+"\n");

              bubbleSort(arr_int);

               System.out.println("Array after Bubble sorting: " + Arrays.toString(arr_int));

     } 
}

The output:

The array is sorted in ascending order.

Demo of sorting double array by Java Bubble sort algorithm

The above algorithm requires a little tweak to enable double array sorting.

See the example below where an array with double elements is created and passed to bubbleSort algo.

Look carefully in the first part to see the difference between two algorithms:

import java.util.*;

public class sort_demo { 

    static void bubbleSort(double[] arr_sort) { 

        int num = arr_sort.length; 

        double z = 0; 

         for(int x=0; x < num; x++){ 

           for(int y=1; y < (num-x); y++){ 

              if(arr_sort[y-1] > arr_sort[y]){ 

                z = arr_sort[y-1]; 

                arr_sort[y-1] = arr_sort[y]; 

                arr_sort[y] = z; 

               } 
             } 

        } 

    }

         public static void main(String[] args) { 

           double[] arr_double = {1.5,9.5,19.5,5,1.8,-1.4,-11.5};
           System.out.println("double array before Bubble sorting: " + Arrays.toString(arr_double)+"\n");

           bubbleSort(arr_double);

            System.out.println("double array after Bubble sorting: " + Arrays.toString(arr_double));

     } 
}

The Output:

Likewise, you may use the Double and Integer etc/ objects sorting as using the bubble sort solution.