Array Sorting in Java — Appended Items Break Binary Search

Every real application deals with ordered data. A leaderboard ranks players by score. A contacts list shows names alphabetically. A shop sorts products by price. None of that is possible if your data is sitting in random order. Sorting is one of the most fundamental operations in programming, and the sooner you get comfortable with it, the faster you'll be able to build things that actually feel polished and useful.

Before sorting existed as a built-in feature, developers had to write dozens of lines of code manually swapping values around — a slow, error-prone nightmare. Java's Arrays utility class solves this entirely. It ships with a sort() method powered by a highly optimised algorithm under the hood, so you get fast, reliable sorting in a single line of code without needing to understand the internals.

By the end you'll know how to sort primitive arrays in ascending order, reverse them into descending order, sort arrays of strings alphabetically, write a custom sort rule using a Comparator, and avoid the classic traps that trip up beginners. You'll walk away with working code you can drop straight into a real project.

Sorting a Basic Number Array With Arrays.sort()

Before you can sort anything, you need to import Java's Arrays class. It lives in the java.util package and it's the toolbox that contains sort() and many other helpful array utilities. Think of it like importing a specialised calculator — once it's imported, all its functions are available to you.

Arrays.sort() takes your array as an argument and sorts it in-place. 'In-place' means it rearranges the values inside the original array — it doesn't create a new one. After the method runs, your original variable now holds the sorted data. This is important to keep in mind because there's no 'undo' — the original order is gone.

For arrays of primitive numbers (int, double, long etc.), the default sort is always ascending — smallest value first, largest value last. This mirrors natural numeric order, the same way you'd read numbers on a number line from left to right.

The algorithm Java uses internally for primitive arrays is called Dual-Pivot Quicksort. You don't need to understand it yet, but know that it's extremely fast — even an array of a million numbers sorts in a fraction of a second.

package io.thecodeforge.sorting;

import java.util.Arrays; // Gives us access to the Arrays utility class

public class SortStudentScores {

    public static void main(String[] args) {

        // A class of 6 students just got their test results back — completely out of order
        int[] studentScores = { 78, 45, 92, 61, 33, 88 };

        // Print the scores BEFORE sorting so we can see the difference
        System.out.println("Before sorting: " + Arrays.toString(studentScores));

        // Arrays.sort() rearranges the values inside studentScores from low to high
        // No new array is created — the same array is modified directly
        Arrays.sort(studentScores);

        // Print the scores AFTER sorting — now lowest to highest
        System.out.println("After sorting:  " + Arrays.toString(studentScores));

        // We can now easily find the lowest score (index 0) and highest (last index)
        int lowestScore  = studentScores[0];
        int highestScore = studentScores[studentScores.length - 1];

        System.out.println("Lowest score:   " + lowestScore);
        System.out.println("Highest score:  " + highestScore);
    }
}

Sorting Strings Alphabetically and Numbers in Descending Order

Sorting strings works exactly the same way as sorting numbers — just call Arrays.sort() and Java handles the alphabetical ordering for you. Under the hood, Java compares strings character by character using their Unicode values, which means uppercase letters ('A' = 65) sort before lowercase letters ('a' = 97). For everyday words that share the same case, this just looks like normal A-to-Z ordering.

Now, what about descending order — highest to lowest? This is where things get slightly different. Arrays.sort() has no built-in 'reverse' flag for primitive arrays. The cleanest workaround for int[] is to sort ascending first, then reverse the array manually. Alternatively, you can switch from a primitive int[] to an Integer[] (the object wrapper version), which unlocks a second form of Arrays.sort() that accepts a Comparator — a rule that tells Java how to compare two items.

Comparators.reverseOrder() is a ready-made comparator that flips the sort direction. Think of it as telling Java: 'for every comparison you make, do the opposite of what you'd normally do.'

This section shows both approaches side by side so you can choose whichever fits your situation.

package io.thecodeforge.sorting;

import java.util.Arrays;
import java.util.Collections; // Needed for Collections.reverseOrder()

public class SortNamesAndRankings {

    public static void main(String[] args) {

        // ── PART 1: Sort a String array alphabetically ──────────────────────
        String[] playerNames = { "Zara", "Ahmed", "Priya", "Luca", "Mei" };

        System.out.println("Names before sort: " + Arrays.toString(playerNames));

        Arrays.sort(playerNames); // Sorts A-to-Z using Unicode/alphabetical order

        System.out.println("Names after sort:  " + Arrays.toString(playerNames));

        // ── PART 2: Sort integers in DESCENDING order (highest first) ────────
        // We must use Integer[] (capital I — the object wrapper) NOT int[]
        // because Collections.reverseOrder() only works with objects, not primitives
        Integer[] highScores = { 1500, 3200, 800, 4750, 2100 };

        System.out.println("\nScores before sort: " + Arrays.toString(highScores));

        // Pass Collections.reverseOrder() as the second argument to flip the sort
        Arrays.sort(highScores, Collections.reverseOrder());

        System.out.println("Scores after sort:  " + Arrays.toString(highScores));

        // The top player's score is now conveniently sitting at index 0
        System.out.println("Top score belongs to: " + playerNames[0] + " with " + highScores[0]);
    }
}

Custom Sorting Rules With a Comparator (Sort by Word Length, Not Alphabet)

Sometimes alphabetical or numeric order isn't what you need. What if you want to sort a list of movie titles by how long the title is — shortest first? Or sort products by the number of characters in their name? This is where a custom Comparator comes in.

A Comparator is simply a rule that tells Arrays.sort() how to decide which of two elements should come first. You hand it two items — call them 'a' and 'b' — and your rule returns a negative number if 'a' should come first, a positive number if 'b' should come first, or zero if they're equal. Java uses this rule for every comparison it makes during the sort.

In modern Java (version 8 and above) you can write a Comparator as a lambda expression — a short, inline piece of logic that looks like an arrow: (a, b) -> someRule. This means you don't need to write a whole separate class just to define one comparison rule.

Once you understand this pattern, you can sort absolutely anything by any rule you can imagine — it's one of the most powerful and flexible tools in Java.

package io.thecodeforge.sorting;

import java.util.Arrays;

public class SortMovieTitlesByLength {

    public static void main(String[] args) {

        String[] movieTitles = {
            "Inception",
            "Up",
            "The Dark Knight",
            "Dune",
            "Interstellar"
        };

        System.out.println("Titles before sort: " + Arrays.toString(movieTitles));

        // Custom Comparator using a lambda expression:
        // (a, b) -> Integer.compare(a.length(), b.length())
        //
        // For each pair of titles, compare their lengths:
        //   - If a is shorter than b  → negative number → a goes first
        //   - If a is longer than b   → positive number → b goes first
        //   - If equal length         → 0               → keep current order
        Arrays.sort(movieTitles, (a, b) -> Integer.compare(a.length(), b.length()));

        System.out.println("Titles sorted by length (short → long):");

        // Loop through and print each title with its character count
        for (String title : movieTitles) {
            System.out.println("  " + title + " (" + title.length() + " chars)");
        }

        // BONUS: Reverse the lambda to get longest title first
        // Simply swap a and b in the comparison: compare(b.length(), a.length())
        Arrays.sort(movieTitles, (a, b) -> Integer.compare(b.length(), a.length()));

        System.out.println("\nTitles sorted by length (long → short):");
        for (String title : movieTitles) {
            System.out.println("  " + title + " (" + title.length() + " chars)");
        }
    }
}

Time and Space Complexity: Dual-Pivot Quicksort vs TimSort

Java uses two different sorting algorithms under the hood depending on whether the array contains primitives or objects. Understanding the complexity of each helps you predict performance for different data sizes and choose the right tool.

Dual-Pivot Quicksort is in-place (negligible extra memory) and very cache-friendly, making it ideal for primitives. Its worst-case O(n²) occurs only on pathological data (e.g., already sorted with specific pivot choices). Java mitigates this with randomised pivots.

TimSort is a hybrid of merge sort and insertion sort. It's stable (equal elements keep original order) and guarantees O(n log n) worst-case. The O(n) space comes from temporary arrays for merging. Stability is essential for objects because the sort may be a secondary operation after a primary sort (e.g., sort by name, then by age).

Production note: TimSort's space usage can be a concern for huge arrays on memory-constrained systems. If you have a 100 million element Integer[] array, TimSort may require up to 100 million extra references (roughly 800 MB for the temporary array). For primitive arrays, Dual-Pivot Quicksort uses almost no extra memory.

Collections.sort() vs Arrays.sort() — When to Use Which

Both Collections.sort() and Arrays.sort() use TimSort for object arrays, but they operate on different data structures. Collections.sort() sorts List implementations (like ArrayList, LinkedList), while Arrays.sort() sorts arrays directly.

When to use which: - If your data is in an array (e.g., from legacy code or fixed-size buffer), use Arrays.sort(). - If your data is in a List (modern Java prefers collections), use Collections.sort(). - For primitive arrays, Arrays.sort() is the only option. - For large object collections that need stable sorting, both behave identically.

Production trap: Collections.sort() on a LinkedList is very inefficient because TimSort needs O(n log n) random accesses; LinkedList gives O(n) access per element. Always sort ArrayList-backed lists, not LinkedList.

Sorting with Stream API: sorted() and sorted(Comparator)

Java 8 introduced the Stream API, which provides a functional way to sort arrays without mutating the original. The stream().sorted() method returns a new stream with elements sorted, leaving the original array untouched. This is ideal for one-off sorting where you don't want to modify the source array.

Stream.sorted() with natural order: ``java int[] numbers = {5, 3, 8, 1, 9}; int[] sorted = Arrays.stream(numbers).sorted().toArray(); System.out.println(Arrays.toString(sorted)); // [1, 3, 5, 8, 9] ``

Stream.sorted() with Comparator: For object arrays, you can pass a Comparator: ``java String[] names = {"Zara", "Ahmed", "Priya"}; String[] sortedDesc = Arrays.stream(names) .sorted(Comparator.reverseOrder()) .toArray(String[]::new); ``

Custom comparator with method references: ``java List<Person> people = ...; List<Person> sorted = people.stream() .sorted(Comparator.comparing(Person::getAge)) .collect(Collectors.toList()); ``

Performance considerations: Stream sorting creates a copy of the data. For large arrays, this doubles memory usage. However, the copy is temporary and will be garbage collected. If you need to sort the original array in-place for performance, use Arrays.sort() instead.

package io.thecodeforge.sorting;

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

public class StreamSortDemo {

    public static void main(String[] args) {
        // Primitive array sorted with streams (does not modify original)
        int[] scores = {88, 45, 92, 61, 33};
        int[] sortedScores = Arrays.stream(scores).sorted().toArray();
        System.out.println("Original: " + Arrays.toString(scores));
        System.out.println("Sorted:   " + Arrays.toString(sortedScores));

        // Object array sorted descending
        String[] players = {"Zara", "Ahmed", "Priya", "Luca"};
        String[] descending = Arrays.stream(players)
                .sorted(Comparator.reverseOrder())
                .toArray(String[]::new);
        System.out.println("Descending: " + Arrays.toString(descending));

        // Custom comparator: sort by string length
        String[] movies = {"Inception", "Up", "Interstellar"};
        String[] byLength = Arrays.stream(movies)
                .sorted(Comparator.comparingInt(String::length))
                .toArray(String[]::new);
        System.out.println("By length: " + Arrays.toString(byLength));
    }
}

Parallel Sorting with Arrays.parallelSort()

Arrays.parallelSort() is a multi-threaded version of sorting that splits the array into chunks, sorts each chunk in parallel using the Fork/Join pool, then merges the results. It is available for both primitive and object arrays.

When to use: - Array size > 10 million elements (threshold varies by system, typically ~8192 for the parallel branch) - Sorting is a bottleneck and you have multiple CPU cores - You are sorting on a non-real-time thread (the Fork/Join pool can delay other tasks)

When NOT to use: - Small arrays (overhead of thread management outweighs benefits) - Real-time or latency-sensitive applications (parallel sorting may block the common Fork/Join pool) - Memory-constrained environments (parallelSort uses additional temporary arrays for merging)

Performance: On a typical 4-core machine, parallelSort can be 2-4x faster for arrays of 10 million integers. The speedup diminishes with more cores due to memory bandwidth limits.

Code example: ``java int[] bigArray = new int[50_000_000]; // fill array... Arrays.parallelSort(bigArray); // sorts using multiple threads ``

Under the hood: The array is divided into subarrays equal to the number of available processors. Each subarray is sorted independently using Dual-Pivot Quicksort (primitives) or TimSort (objects). Then a merge operation combines them.

package io.thecodeforge.sorting;

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

public class ParallelSortDemo {

    public static void main(String[] args) {
        // Create a large array
        int size = 10_000_000;
        int[] data = new int[size];
        Random rand = new Random();
        for (int i = 0; i < size; i++) {
            data[i] = rand.nextInt(1_000_000);
        }

        // Time regular sort
        int[] copy1 = data.clone();
        long start = System.nanoTime();
        Arrays.sort(copy1);
        long regularTime = System.nanoTime() - start;

        // Time parallel sort
        int[] copy2 = data.clone();
        start = System.nanoTime();
        Arrays.parallelSort(copy2);
        long parallelTime = System.nanoTime() - start;

        System.out.println("Regular sort:  " + regularTime / 1_000_000 + " ms");
        System.out.println("Parallel sort: " + parallelTime / 1_000_000 + " ms");
        System.out.println("Speedup: " + (regularTime / (double) parallelTime) + "x");
    }
}

Multi-Key Sorting with Comparator.comparing() and thenComparing()

Sorting by multiple fields is a common requirement: sort employees by department, then by salary within the same department, then by name. Java 8 introduced factory methods in the Comparator interface that make this clean and composable.

Comparator.comparing() extracts a key and returns a comparator that sorts by that key. It's like a lambda that says: "compare two objects by comparing one property of each."

Chaining with thenComparing() adds secondary sort criteria. If two objects are equal by the first comparator, the second one is used, and so on.

Syntax: ```java Comparator<Person> multiComparator = Comparator .comparing(Person::getDepartment) // primary: department name .thenComparingInt(Person::getSalary) // secondary: salary (ascending) .thenComparing(Person::getName); // tertiary: name

Arrays.sort(people, multiComparator); ```

You can reverse any step by calling .reversed() on that comparator. For example, Comparator.comparing(Person::getDepartment).reversed().thenComparingInt(Person::getSalary) sorts by department descending, then salary ascending.

Important: When chaining, be careful with .reversed() placement. To reverse the entire comparator, call .reversed() at the end: multiComparator.reversed().

package io.thecodeforge.sorting;

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

class Employee {
    String name;
    String department;
    int salary;

    Employee(String name, String department, int salary) {
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return String.format("%s (%s, $%d)", name, department, salary);
    }
}

public class MultiKeySortDemo {

    public static void main(String[] args) {
        Employee[] team = {
            new Employee("Alice", "Engineering", 120000),
            new Employee("Bob",   "Engineering", 95000),
            new Employee("Carol", "Sales",       110000),
            new Employee("Dave",  "Engineering", 120000),
            new Employee("Eve",   "Sales",       95000)
        };

        System.out.println("Before sorting:");
        Arrays.stream(team).forEach(System.out::println);

        // Sort by department (ascending), then by salary descending, then by name ascending
        Comparator<Employee> byDept = Comparator.comparing(Employee::getDepartment);
        Comparator<Employee> bySalaryDesc = Comparator.comparingInt(Employee::getSalary).reversed();
        Comparator<Employee> byName = Comparator.comparing(Employee::getName);

        Comparator<Employee> multi = byDept.thenComparing(bySalaryDesc).thenComparing(byName);

        Arrays.sort(team, multi);

        System.out.println("\nAfter sorting (dept asc, salary desc, name asc):");
        Arrays.stream(team).forEach(System.out::println);
    }
}

Sorting a 2D Array in Java

2D arrays (arrays of arrays) are common in grid-based problems, matrix operations, and data tables. Sorting a 2D array usually means sorting rows based on the values in one or more columns.

Sort by a specific column: Use a custom comparator that compares the elements at the chosen column index.

Example: sort by first column ascending, second column descending: ```java int[][] matrix = { {5, 2}, {1, 9}, {5, 1}, {3, 7} };

Arrays.sort(matrix, (a, b) -> { if (a[0] != b[0]) return Integer.compare(a[0], b[0]); // first column asc else return Integer.compare(b[1], a[1]); // second column desc }); ```

This syntax works because the 2D array is an array of int[] objects. The comparator receives two rows (int[]), and you compare specific indices.

For stable sorting with multiple columns: Use Comparator.comparingInt(row -> row[0]).thenComparingInt(row -> -row[1]) but careful with negation overflow. Better to use the lambda with explicit Integer.compare.

Sorting an array of arrays by multiple fields (like SQL ORDER BY): You can chain comparators using method references if you have a simple class, but for raw 2D arrays, lambdas are clearest.

package io.thecodeforge.sorting;

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

public class Sort2DArray {

    public static void main(String[] args) {
        int[][] grid = {
            {4, 2, 7},
            {1, 9, 3},
            {4, 2, 1},
            {3, 5, 6}
        };

        System.out.println("Original:");
        print2D(grid);

        // Sort by column 0 ascending, then column 1 descending, then column 2 ascending
        Arrays.sort(grid, (a, b) -> {
            if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
            if (a[1] != b[1]) return Integer.compare(b[1], a[1]);
            return Integer.compare(a[2], b[2]);
        });

        System.out.println("\nSorted (col0 asc, col1 desc, col2 asc):");
        print2D(grid);

        // Alternative using Comparator.comparing() with reversed() – note reversed() reverses entire chain
        // Best for single-column sorts:
        // Arrays.sort(grid, Comparator.comparingInt(row -> row[0]));
    }

    private static void print2D(int[][] arr) {
        for (int[] row : arr) {
            System.out.println(Arrays.toString(row));
        }
    }
}

Practice Exercises: Sorting Arrays in Java

Sharpen your sorting skills with these real-world exercises. Each builds on concepts from this guide.

Exercise 1: Sort objects by multiple fields Create a Student class with fields name (String), grade (int), and age (int). Create an array of 10 students with varied data. Sort them by grade descending, then by age ascending, then by name alphabetically. Print the sorted list.

Exercise 2: Sort a 2D array by column Given a 2D array int[][] scores = {{3, 5, 1}, {2, 8, 7}, {3, 5, 3}}; sort the rows by first column ascending, then second column descending, then third column ascending. Verify the result.

Exercise 3: Partial sort using Arrays.sort() Create an int array of 20 random numbers. Sort only the elements from index 5 to index 14 (inclusive) using Arrays.sort(arr, fromIndex, toIndex). Leave the rest untouched. Print the array to verify the partial sort.

Exercise 4: Sort strings by custom rule Given an array of strings, sort them by the number of vowels in each word (case-insensitive). If two words have the same vowel count, sort them by their natural (alphabetical) order. Hint: define a helper method to count vowels.

Exercise 5: Merge sorted arrays Create two sorted int arrays: a = {1, 3, 5, 7} and b = {2, 4, 6, 8}. Merge them into a single sorted array without using Arrays.sort() on the combined array. Use a two-pointer approach. Then verify the result is sorted.

Bonus challenge: Implement a custom sort() method that uses insertion sort for small arrays (size < 20) and delegates to Arrays.sort() for larger ones. Measure the performance difference on 100 random arrays of varying sizes.