# Sorting in Java

• Difficulty Level : Easy
• Last Updated : 29 Sep, 2022

Whenever we do hear sorting algorithms come into play such as selection sort, bubble sort, insertion sort, radix sort, bucket sort, etc but if we look closer here we are not asked to use any kind of algorithms. It is as simple sorting with the help of linear and non-linear data structures present within java. So there is sorting done with the help of brute force in java with the help of loops and there are two in-built methods to sort in Java.

Ways of sorting in Java

1. Using loops
2. Using sort() method of Arrays class
3. Using sort method of Collections class
4. Sorting on a subarray

Let us discuss all four of them and propose a code for each one of them.

Way 1: Using loops

## Java

 `// Java Program to sort an elements``// by bringing Arrays into play` `// Main class``class` `GFG {` `    ``// Main driver method``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Custom input array``        ``int` `arr[] = { ``4``, ``3``, ``2``, ``1` `};` `        ``// Outer loop``        ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `            ``// Inner nested loop pointing 1 index ahead``            ``for` `(``int` `j = i + ``1``; j < arr.length; j++) {` `                ``// Checking elements``                ``int` `temp = ``0``;``                ``if` `(arr[j] < arr[i]) {` `                    ``// Swapping``                    ``temp = arr[i];``                    ``arr[i] = arr[j];``                    ``arr[j] = temp;``                ``}``            ``}` `            ``// Printing sorted array elements``            ``System.out.print(arr[i] + ``" "``);``        ``}``    ``}``}`

Output

`1 2 3 4 `

Time Complexity: O(N2)
Auxiliary Space: O(1)

Way 2: Using sort() method of Arrays class

Arrays.Sort() works for arrays which can be of primitive data type also which in turn by default sorts in ascending order.

Example 1

## JAVA

 `// Java program to demonstrate working of``// sort() method of Arrays class` `// Importing Arrays class from java.util package``import` `java.util.Arrays;` `// Main class``public` `class` `GFG {` `    ``// Main driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Custom input array``        ``int``[] arr = { ``13``, ``7``, ``6``, ``45``, ``21``, ``9``, ``101``, ``102` `};` `        ``// Calling the sort() method present``        ``// inside Arrays class``        ``Arrays.sort(arr);` `        ``// Printing and display sorted array``        ``System.out.printf(``"Modified arr[] : %s"``,``                          ``Arrays.toString(arr));``    ``}``}`

Output

`Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]`

Time Complexity: O(N log N)
Auxiliary Space: O(1)

Example 2

## JAVA

 `// A sample Java program to sort an array``// in descending order using Arrays.sort().``import` `java.util.Arrays;``import` `java.util.Collections;` `public` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Note that we have Integer here instead of``        ``// int[] as Collections.reverseOrder doesn't``        ``// work for primitive types.``        ``Integer[] arr = { ``13``, ``7``, ``6``, ``45``, ``21``, ``9``, ``2``, ``100` `};` `        ``// Sorts arr[] in descending order``        ``Arrays.sort(arr, Collections.reverseOrder());` `        ``System.out.printf(``"Modified arr[] : %s"``,``                          ``Arrays.toString(arr));``    ``}``}`

Output

`Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]`

Time Complexity: O(N log N)
Auxiliary Space: O(1)

Way 3: Using sort() method of Collections class

Collections.sort() works for objects Collections like ArrayList and LinkedList.

Example

## JAVA

 `// Java program to demonstrate working of Collections.sort()``import` `java.util.*;` `public` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Create a list of strings``        ``ArrayList al = ``new` `ArrayList();``        ``al.add(``"Geeks For Geeks"``);``        ``al.add(``"Friends"``);``        ``al.add(``"Dear"``);``        ``al.add(``"Is"``);``        ``al.add(``"Superb"``);` `        ``/* Collections.sort method is sorting the``        ``elements of ArrayList in ascending order. */``        ``Collections.sort(al);` `        ``// Let us print the sorted list``        ``System.out.println(``"List after the use of"``                           ``+ ``" Collection.sort() :\n"` `+ al);``    ``}``}`

Output

```List after the use of Collection.sort() :
[Dear, Friends, Geeks For Geeks, Is, Superb]```

Time Complexity: O(N log N)
Auxiliary Space: O(1)

Example 2

## JAVA

 `// Java program to demonstrate working of Collections.sort()``// to descending order.``import` `java.util.*;` `public` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Create a list of strings``        ``ArrayList al = ``new` `ArrayList();``        ``al.add(``"Geeks For Geeks"``);``        ``al.add(``"Friends"``);``        ``al.add(``"Dear"``);``        ``al.add(``"Is"``);``        ``al.add(``"Superb"``);` `        ``/* Collections.sort method is sorting the``        ``elements of ArrayList in ascending order. */``        ``Collections.sort(al, Collections.reverseOrder());` `        ``// Let us print the sorted list``        ``System.out.println(``"List after the use of"``                           ``+ ``" Collection.sort() :\n"` `+ al);``    ``}``}`

Output

```List after the use of Collection.sort() :
[Superb, Is, Geeks For Geeks, Friends, Dear]```

Time Complexity: O(N log N)
Auxiliary Space: O(1)

Way 4: Sorting only a subarray

## JAVA

 `// Java program to sort a subarray``// using Arrays.sort()` `// Importing Arrays class from java.util package``import` `java.util.Arrays;` `// Main class``public` `class` `GFG {` `    ``// Main drive method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Custom input array``        ``int``[] arr = { ``13``, ``7``, ``6``, ``45``, ``21``, ``9``, ``2``, ``100` `};` `        ``// Sort subarray from index 1 to 4, i.e.,``        ``// only sort subarray {7, 6, 45, 21} and``        ``// keep other elements as it is.``        ``Arrays.sort(arr, ``1``, ``5``);` `        ``// Printing sorted array``        ``System.out.printf(``"Modified arr[] : %s"``,``                          ``Arrays.toString(arr));``    ``}``}`

Output

`Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]`

Time Complexity: O(N log N)
Auxiliary Space: O(1)

Note:

• Which sorting algorithm does Java use in sort()?
Previously, Java’s Arrays.sort method used Quicksort for arrays of primitives and Merge sort for arrays of objects. In the latest versions of Java, Arrays.sort method and Collection.sort() uses Timsort.
• Which order of sorting is done by default?
It by default sorts in ascending order.
• How to sort array or list in descending order?
It can be done with the help of Collections.reverseOrder().
• How to write my own sorting function in Java?
Please see Java programs for Quick Sort, Merge Sort, Insertion Sort, Selection Sort, Heap Sort, Bubble Sort

My Personal Notes arrow_drop_up