Arrays.sort() in Java

Sorting is one of the most common operations in programming. In Java, the Arrays.sort() method provides a fast and efficient way to sort arrays of primitive types and objects. Whether you're a beginner or an intermediate Java developer, understanding how to use this method is crucial for writing clean, optimized code.

What is Arrays.sort() in Java?

The Arrays.sort() method is a built-in utility in the java.util.arrays class that sorts the elements of an array into ascending order. For objects, it uses the natural ordering or a custom comparator.

How Arrays.sort() Works

Internally, the Arrays.sort() method uses different algorithms depending on the type of array:

• ForFor primitive types like int,double etc., it uses a dual-pivot Quicksort algorithm.
• For object arrays, it uses a tuned version of MergeSort (TimSort) to maintain stability.

Sorting a Simple Integer Array

Sorting an array of integers is one of the most common tasks in Java. You can use Arrays.sort() to sort the array in ascending order effortlessly.

📄
import java.util.Arrays;

public class SortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 9, 1, 5, 6};
        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));
    }
}

Output:

📄
Sorted array: [1, 2, 5, 5, 6, 9]

Explanation:

• convert the array into a readable string format for printing.
• Duplicates in the array are maintained, and the elements are rearranged in increasing order.

Here is an example of sorting an integer array:

📄
import java.util.Arrays;

public class SortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 9, 1, 5, 6};
        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));
    }
}

Output:

📄
Sorted array: [1, 2, 5, 5, 6, 9]

Sorting Arrays of Objects

When working with custom objects, the objects must implement the interface, or you need to provide a comparable

Example: Sorting Objects Naturally

📄
import java.util.Arrays;

class Student implements Comparable<Student> {
    String name;
    int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student s) {
        return this.age - s.age; // Sort by age
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class StudentSortExample {
    public static void main(String[] args) {
        Student[] students = {
            new Student("Alice", 22),
            new Student("Bob", 20),
            new Student("Charlie", 25)
        };

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

Output:

📄
[Bob (20), Alice (22), Charlie (25)]

Using a Custom Comparator

If you want to sort objects in a different order (e.g., descending), you can use a

📄
import java.util.Arrays;
import java.util.Comparator;

public class CustomSortExample {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 9, 1, 5, 6};

        // Sort in descending order
        Arrays.sort(numbers, Comparator.reverseOrder());
        System.out.println("Descending order: " + Arrays.toString(numbers));
    }
}

Output:

📄
Descending order: [9, 6, 5, 5, 2, 1]

Real-World Use Cases of Arrays.sort()

• Sorting user data by age, name, or score.
• Organizing products in e-commerce applications by price.
• Ranking search results or leaderboard scores.
• Preprocessing data before binary search operations.

Key Points to Remember

• In-place sorting: Arrays.sort() sorts the array in-place without creating a new array.
• Ascending by default: Primitive arrays are sorted in ascending order unless a comparator is provided.
• Stable sort for objects: When sorting objects, the relative order of equal elements is preserved.
• Performance: Dual-pivot Quicksort for primitives is O(n log n) on average.

Conclusion

The Arrays.sort() method is a versatile and efficient way to sort arrays in Java, whether they contain primitives or objects. Understanding its syntax, internal mechanisms, and best practices ensures that your Java programs handle sorting operations effectively. By mastering this method, you can optimize applications ranging from simple scripts to large-scale enterprise software.

Frequently Asked Questions (FAQs)

1. Can Arrays.sort() sort in descending order?

Yes, for object arrays, you can use a comparator such as comparator reverseorder() to sort in descending order. Primitive arrays need to be boxed into their wrapper classes (e.g., int to Integer) first.

2. Does Arrays.sort() change the original array?

Yes, it sorts the array in-place and does not create a new array. The original array elements are reordered.

3. What is the difference between Arrays.sort() and Collections.sort()?

Arrays.sort() is used for arrays, while Collections.sort() is used for List objects. Arrays.sort() works with both primitive and object arrays, whereas Collections.sort() works only with objects.

4. Is Arrays.sort() stable?

Arrays.sort() is stable for object arrays, meaning equal elements maintain their relative order. However, primitive type sorting (using dual-pivot Quicksort) is not guaranteed to be stable.

5. Can we sort a portion of an array?

Yes, you can sort a specific range of an array using the overloaded method.