Sorting Arrays in Java: Methods and Examples

Introduce Java How To Sort an Array and give examples

Sorting an array in Java can be accomplished using various methods, including built-in functions, manual algorithms, and libraries. Below, I'll introduce some common ways to sort an array in Java, along with examples for each method.

1. Using Arrays.sort()

The simplest way to sort an array in Java is to use the Arrays.sort() method from the java.util.Arrays class. This method sorts the array in ascending order.

Example:

import java.util.Arrays;

public class SortArrayExample {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 2};
        
        // Sorting the array
        Arrays.sort(numbers);
        
        // Printing the sorted array
        System.out.println("Sorted array: " + Arrays.toString(numbers));
    }
}

Output:

Sorted array: [1, 2, 3, 5, 8]

2. Sorting an Array of Objects

You can also sort an array of objects by implementing the Comparable interface or using a Comparator.

Example with Comparable:

import java.util.Arrays;

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

    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 SortObjectArrayExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };

        Arrays.sort(people); // Sorts by age

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

Output:

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

3. Using a Custom Comparator

If you want to sort an array of objects based on a different attribute, you can use a Comparator.

Example:

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

class Person {
    String name;
    int age;

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

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

public class SortWithComparatorExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };

        // Sort by name using a custom comparator
        Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.name.compareTo(p2.name);
            }
        });

        System.out.println("Sorted people by name: " + Arrays.toString(people));
    }
}

Output:

Sorted people by name: [Alice (30), Bob (25), Charlie (35)]

4. Manual Sorting Algorithms

You can also implement sorting algorithms manually, such as Bubble Sort, Selection Sort, or Quick Sort. Here’s an example of Bubble Sort:

Example of Bubble Sort:

public class BubbleSortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 2};
        
        // Bubble Sort algorithm
        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = 0; j < numbers.length - 1 - i; j++) {
                if (numbers[j] > numbers[j + 1]) {
                    // Swap
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }

        // Printing the sorted array
        System.out.println("Sorted array using Bubble Sort: " + Arrays.toString(numbers));
    }
}

Output:

Sorted array using Bubble Sort: [1, 2, 3, 5, 8]

Conclusion

Java provides several ways to sort arrays, from built-in methods to custom implementations. The Arrays.sort() method is the most straightforward and efficient for most use cases, while implementing your own sorting algorithm can be a good exercise for understanding sorting mechanics.