Example:

int[] myArray = {5, 9, 1, 3};
Arrays.sort(myArray);
System.out.println(Arrays.toString(myArray)); // Output: [1, 3, 5, 9]

2. Sorting with a Comparator

For arrays of custom objects or for arrays where you need a different order, Java offers the Comparator interface. This interface allows you to define the exact criteria on which sorting can be based.

Example:

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

class Person {
    int age;
    String name;

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

Person[] people = {
    new Person(40, John),
    new Person(30, Sara),
    new Person(20, Jane)
};

Arrays.sort(people, new Comparator() {
    public int compare(Person a, Person b) {
        return a.age - b.age;
    }
});

3. Using Streams in Java 8 and Above

With the introduction of Streams in Java 8, you can sort arrays more flexibly by converting them to streams. Sorting with streams is helpful especially when dealing with collections or when you want to perform operations in a functional style.

Example:

import java.util.Arrays;
import java.util.stream.Collectors;

Integer[] numbers = {5, 9, 1, 3};

Arrays.stream(numbers)
      .sorted()
      .collect(Collectors.toList())
      .forEach(System.out::println); // Output: 1, 3, 5, 9
.

When to Use Each Sorting Method

Determining which sorting method to use depends on your specific needs:

• Simple sorting: Use Arrays.sort() for quick and efficient sorting of primitives or objects (where natural ordering is acceptable).
• Custom sorting: Use Comparator if you need to sort objects based on specific fields or rules.
• Utilize Java 8 Streams for complex sorting criteria or for more readability and flexibility in sorting operations.

Conclusion

Sorting arrays in Java can be approached in several ways, from straightforward methods using Arrays.sort() to more complex manipulations with Comparators or Streams. Understanding the tools and techniques for array sorting can significantly affect the performance and efficiency of your Java applications.

Here are our top picks for various use cases:

• Beginners or when performance is not a critical issue: Stick with the simplicity of Arrays.sort().
• When specific sorting criteria are needed: Implement a Comparator for greater control over sorting logic.
• When working with collection data structures or require chaining transformations: Use Streams for a modern, functional approach to array sorting.

FAQ

How do you sort an array of integers in descending order?

You can use Arrays.sort(array, Collections.reverseOrder()) for objects or you may need to write a custom sorting method for primitive types.

Can Arrays.sort() be used for arrays of custom objects?

Yes, but the objects must either implement the Comparable interface, or you must provide a Comparator.

What is the time complexity of Arrays.sort()?

For primitive types, it uses a Dual-Pivot QuickSort algorithm, which is O(n log n) on average. For objects, it uses a variant of MergeSort, which guarantees O(n log n) performance.

Does Java have a built-in function to check if an array is sorted?

No, Java does not provide a built-in function to check if an array is sorted. You would need to write a method to verify this manually.

Is it better to sort an array using a loop or built-in methods?

Using built-in methods like Arrays.sort() is generally recommended for most cases due to its efficiency and simplicity, unless specific modifications are needed that require a custom sorting algorithm.

Feel free to comment, ask questions, or share your experiences with Java sorting methods below. Your feedback is valuable in enhancing knowledge around practical Java programming!