Java sorting is a neat trick to unlock accuracy and performance. It provides an organized dataset that powers smooth data processing and lays the groundwork for high-level algorithms. Join me in this guide to understand what sorting is in Java through its meaning, importance, sorting algorithms in Java along with other real-world applications. Let me guide you into writing smart and real-world code through this blog.
In Java, sorting means the process of arranging elements in a specific order. It is important to note that this arrangement is usually in ascending or descending sequence. This operation is important in computer science for organizing data to make it more efficient to search, view and display.
But, why do we need Java sorting? Let’s understand the importance of sorting in Java through the following points -
Users require a bit organization while working with lists like contact directions, search results, and product catalogs. Sorting helps organize information clearly and improve overall usability.
Java sorting creates a clear and structured base when data is stored. This makes tasks like statistical analysis, report generation and aggregation much smoother and accurate.
Read Also: Java Tutorial For Beginners
Given are the four common ways of sorting in Java with examples -
This method works for object collections like LinkedList and ArrayList. Here is an example to help you understand better -
// 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<String> al = new ArrayList al.add("igmGuru"); 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); } } |
This is what the output would look like -
List after the use of Collection.sort() : [Dear, Friends, igmGuru, Is, Superb] |
Here is an example of using loops for Java sorting -
// 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] + " "); } } } |
This is what the output would look like -
| 1 2 3 4 |
Let’s take a look at the following example to understand how sorting on a subarray works -
// 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)); } } |
| Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100] |
// 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)); } } |
This is what the output would look like -
// 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)); } } |
| Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102] |
Let’s understand some sorting algorithms in Java to grasp a strong understanding.
You can use the comparator or implement the Comparable interface to sort collections of objects or arrays based on custom criteria.
import java.util.Arrays; public class Student implements Comparable<Student> { private int id; private String name; // Constructor, getters, setters @Override public int compareTo(Student other) { // Compare students based on their IDs return Integer.compare(this.id, other.id); } public static void main(String[] args) { Student[] students = { new Student(3, "Alice"), new Student(1, "Bob"), new Student(2, "Charlie") }; Arrays.sort(students); // Sorting by student IDs System.out.println("Sorted students by ID: "); for (Student student : students) { System.out.println(student.getId() + ": " + student.getName()); |
Sorted students by ID: 1: Bob 2: Charlie 3: Alice |
This method utilizes a specialized version of the quicksort algorithm for sorting arrays of primitive types. It also employs a merge sort algorithm for arrays of objects. It sorts arrays in ascending order by default.
import java.util.Arrays; public class SortingExample { public static void main(String[] args) { int[] numbers = {5, 2, 9, 1, 5, 6}; Arrays.sort(numbers); // Sorting in ascending order System.out.println("Sorted numbers: " + Arrays.toString(numbers)); } } |
| Sorted numbers: [1, 2, 5, 5, 6, 9] |
This method is used to sort collections like ArrayList and LinkedList of objects. It internally depends on the merge sort algorithm.
import java.util.ArrayList; import java.util.Collections; public class SortingExample { public static void main(String[] args) { ArrayList<Integer> numbers = new ArrayList<>(); numbers.add(5); numbers.add(2); numbers.add(9); numbers.add(1); numbers.add(5); numbers.add(6); Collections.sort(numbers); // Sorting in ascending order System.out.println("Sorted numbers: " + numbers); } } |
| Sorted numbers: [1, 2, 5, 5, 6, 9] |
Read Also: 60+ Java Interview Questions and Answers
Here are the real-world applications of sorting in Java.
Online retailers utilize sorting to present products in organized ways, such as by price, popularity, or customer ratings. Java's Collections.sort() and Arrays.sort() methods are frequently employed for this purpose. For instance, sorting products by price allows customers to find items within their budget more easily.
When retrieving data from a database, the results are often sorted before being displayed or further processed. For example, sorting customer records by name or transaction history by date. Sorting algorithms are fundamental to database management systems and are often implemented efficiently in Java database connectors.
Before performing statistical calculations or generating visualizations like charts and graphs, data is frequently sorted to identify patterns, trends, and outliers more easily. Sorting enables efficient processing for tasks like finding the top N elements or grouping similar data points.
In operating systems, processes are often scheduled based on various criteria, which can involve sorting. For instance, processes might be sorted by priority, arrival time, or remaining execution time to optimize resource allocation and system performance.
Search engines rely heavily on sorting to organize and rank search results based on relevance to a user's query. The immense amount of data involved necessitates highly optimized sorting algorithms to deliver fast and accurate search results. While complex ranking algorithms are involved, sorting is a core component in presenting the most relevant information first.
Sorting isn't just a theoretical concept; it's a practical necessity across various industries. From e-commerce platforms organizing product listings to operating systems efficiently scheduling tasks, sorting algorithms in Java power real-world applications that demand speed, accuracy, and scalability.
Yes, Arrays.sort() is stable when sorting objects. This means that if two elements are equal according to the comparator, their relative order is preserved in the sorted array. This stability is achieved because Arrays.sort() uses Timsort, which is a stable sorting algorithm.
The Arrays.sort() method in Java uses the Timsort algorithm, which has: Best and average case: O(n log n). Timsort is a hybrid sorting algorithm derived from merge sort and insertion sort. It is stable and efficient, especially for partially sorted data.
Sorting in Java can be done using arrays, collections, Arrays.sort(), or Collections.sort().
Sorting in Java improves data organization, searching efficiency, and overall program performance.
Java uses Dual-Pivot QuickSort for primitive types and TimSort for objects.
