Java How To: Sort an Array

Sorting arrays is a fundamental operation in programming, and Java provides several efficient ways to accomplish this task. Whether you're dealing with numbers, strings, or custom objects, understanding how to sort arrays in Java can significantly improve your coding skills and the performance of your applications.

In this comprehensive guide, we'll explore various methods to sort arrays in Java, from built-in functions to custom implementations. We'll cover sorting for different data types, handling both ascending and descending orders, and even tackle more complex scenarios. Let's dive in! 🏊‍♂️

Table of Contents

1. Using Arrays.sort() for Simple Sorting

The simplest way to sort an array in Java is by using the Arrays.sort() method. This method is part of the java.util.Arrays class and provides a quick and efficient way to sort arrays of primitive types and objects that implement the Comparable interface.

Sorting Primitive Arrays

Let's start with a simple example of sorting an integer array:

import java.util.Arrays;

public class SimpleSorting {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
        System.out.println("Original array: " + Arrays.toString(numbers));

        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));
    }
}

Output:

Original array: [5, 2, 8, 1, 9, 3, 7, 4, 6]
Sorted array: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, we used Arrays.sort() to sort the integer array in ascending order. The method modifies the original array in-place, meaning it doesn't create a new array but rearranges the elements within the existing one. 📊

Sorting String Arrays

Sorting string arrays works similarly:

import java.util.Arrays;

public class StringSorting {
    public static void main(String[] args) {
        String[] fruits = {"banana", "apple", "cherry", "date", "elderberry"};
        System.out.println("Original array: " + Arrays.toString(fruits));

        Arrays.sort(fruits);
        System.out.println("Sorted array: " + Arrays.toString(fruits));
    }
}

Output:

Original array: [banana, apple, cherry, date, elderberry]
Sorted array: [apple, banana, cherry, date, elderberry]

The strings are sorted in lexicographical order (dictionary order) by default. 📚

2. Sorting in Descending Order

While Arrays.sort() sorts in ascending order by default, you can achieve descending order sorting using a few different approaches.

Using Collections.reverseOrder()

For object arrays (like Integer or String), you can use Collections.reverseOrder() as a comparator:

import java.util.Arrays;
import java.util.Collections;

public class DescendingSorting {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
        System.out.println("Original array: " + Arrays.toString(numbers));

        Arrays.sort(numbers, Collections.reverseOrder());
        System.out.println("Sorted array (descending): " + Arrays.toString(numbers));
    }
}

Output:

Original array: [5, 2, 8, 1, 9, 3, 7, 4, 6]
Sorted array (descending): [9, 8, 7, 6, 5, 4, 3, 2, 1]

Note that we used Integer instead of int here, as Collections.reverseOrder() works with object types. 🔢

Custom Comparator for Descending Order

For more control, you can create a custom comparator:

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

public class CustomDescendingSorting {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
        System.out.println("Original array: " + Arrays.toString(numbers));

        Arrays.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return b.compareTo(a);
            }
        });
        System.out.println("Sorted array (descending): " + Arrays.toString(numbers));
    }
}

This approach gives you more flexibility, especially when dealing with custom objects or complex sorting logic. 🧠

3. Sorting Part of an Array

Sometimes, you might want to sort only a portion of an array. The Arrays.sort() method allows you to specify the range to be sorted:

import java.util.Arrays;

public class PartialSorting {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
        System.out.println("Original array: " + Arrays.toString(numbers));

        Arrays.sort(numbers, 2, 7);  // Sort from index 2 (inclusive) to 7 (exclusive)
        System.out.println("Partially sorted array: " + Arrays.toString(numbers));
    }
}

Output:

Original array: [5, 2, 8, 1, 9, 3, 7, 4, 6]
Partially sorted array: [5, 2, 1, 3, 7, 8, 9, 4, 6]

This feature is particularly useful when you need to maintain the order of certain elements while sorting others. 🔍

4. Sorting Custom Objects

When working with custom objects, you'll need to define how these objects should be compared. There are two main ways to do this:

Implementing Comparable Interface

If your class implements the Comparable interface, you can use Arrays.sort() directly:

import java.util.Arrays;

class Person implements Comparable<Person> {
    private String name;
    private int age;

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

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

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

public class CustomObjectSorting {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        System.out.println("Original array: " + Arrays.toString(people));

        Arrays.sort(people);
        System.out.println("Sorted array: " + Arrays.toString(people));
    }
}

Output:

Original array: [Alice (30), Bob (25), Charlie (35)]
Sorted array: [Bob (25), Alice (30), Charlie (35)]

In this example, we sorted Person objects based on their age. 👥

Using a Custom Comparator

For more flexibility, you can use a custom Comparator:

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

class Person {
    private String name;
    private int age;

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

    public String getName() { return name; }
    public int getAge() { return age; }

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

public class ComparatorSorting {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        System.out.println("Original array: " + Arrays.toString(people));

        Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().compareTo(p2.getName());  // Sort by name
            }
        });
        System.out.println("Sorted by name: " + Arrays.toString(people));

        Arrays.sort(people, Comparator.comparingInt(Person::getAge));  // Sort by age using method reference
        System.out.println("Sorted by age: " + Arrays.toString(people));
    }
}

Output:

Original array: [Alice (30), Bob (25), Charlie (35)]
Sorted by name: [Alice (30), Bob (25), Charlie (35)]
Sorted by age: [Bob (25), Alice (30), Charlie (35)]

This approach allows you to define multiple sorting criteria without modifying the Person class. 🔀

5. Parallel Sorting for Large Arrays

For very large arrays, Java provides a parallel sorting algorithm that can significantly improve performance on multi-core systems:

import java.util.Arrays;
import java.util.Random;

public class ParallelSorting {
    public static void main(String[] args) {
        int[] largeArray = new int[1000000];
        Random rand = new Random();
        for (int i = 0; i < largeArray.length; i++) {
            largeArray[i] = rand.nextInt(1000000);
        }

        long startTime = System.nanoTime();
        Arrays.parallelSort(largeArray);
        long endTime = System.nanoTime();

        System.out.println("Parallel sorting took " + (endTime - startTime) / 1000000 + " milliseconds");
        System.out.println("First 10 elements: " + Arrays.toString(Arrays.copyOf(largeArray, 10)));
    }
}

This example demonstrates how to use Arrays.parallelSort() for efficient sorting of large arrays. The actual performance improvement will depend on your system's capabilities. ⚡

6. Stability in Sorting

A stable sorting algorithm maintains the relative order of equal elements. Java's Arrays.sort() is stable for object arrays but not guaranteed to be stable for primitive arrays. If stability is crucial, consider using Collections.sort() on a List:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Student {
    String name;
    int grade;

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

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

public class StableSorting {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 85));
        students.add(new Student("Bob", 90));
        students.add(new Student("Charlie", 85));
        students.add(new Student("David", 90));

        System.out.println("Original list: " + students);

        Collections.sort(students, (s1, s2) -> s2.grade - s1.grade);  // Sort by grade descending
        System.out.println("Sorted list: " + students);
    }
}

Output:

Original list: [Alice (85), Bob (90), Charlie (85), David (90)]
Sorted list: [Bob (90), David (90), Alice (85), Charlie (85)]

Notice how the relative order of students with the same grade is maintained. 📊

Conclusion

Sorting arrays in Java is a versatile operation with multiple approaches to suit different needs. From the simple Arrays.sort() for basic sorting to custom comparators for complex objects, Java provides a rich set of tools for efficient array sorting.

Remember these key points: