Array Sorting in Java — Appended Items Break Binary Search

Arrays.sort() runs once, not continuously.

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.

Why Array Sorting in Java Is Not a One-Time Operation

Array sorting in Java rearranges elements into a defined order — ascending by default via Arrays.sort(), which uses Dual-Pivot Quicksort for primitives (O(n log n) average) and TimSort for objects (O(n log n) worst-case). The core mechanic is in-place mutation: the original array reference is unchanged, but its contents are permuted. This is critical because any code holding that reference now sees sorted data, which can break assumptions made before the sort.

A sorted array enables O(log n) binary search via Arrays.binarySearch(), but only if the array remains sorted. Appending a single element after sorting invalidates the precondition — binary search will return arbitrary negative values or miss the element entirely. The array is not a self-maintaining structure; it is a static snapshot. Developers often forget that Arrays.sort() does not lock the array or prevent future modifications.

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.

Sorting a Subarray: Because Your Boss Doesn't Need the Whole Mess

You don't always need to flatten the entire array. Sometimes you only care about a chunk — maybe the first 50 rows of a paginated report, or a sliding window in a telemetry buffer. Arrays.sort() lets you sort a subrange without copying or mutating the rest. The signature is dead simple: Arrays.sort(arr, fromIndex, toIndex). That fromIndex is inclusive, toIndex is exclusive — classic Java half-open range, same as List.subList(). Why does this matter? Because copying an array just to sort part of it burns CPU and memory. Production services at 10k QPS don't have cycles for that. Use subarray sorting when you're processing sorted windows in streaming data or when you need to partially sort results for a UI with virtual scrolling. It's not a general-purpose tool — but when you need it, it's the difference between a clean solution and a hack job.

// io.thecodeforge — java tutorial

import java.util.Arrays;

public class SubarraySortDemo {
    public static void main(String[] args) {
        int[] telemetryReadings = {42, 7, 13, 99, 88, 2, 55, 31, 77, 64};
        
        // Sort indices 2 through 6 (inclusive: 2, exclusive: 7)
        Arrays.sort(telemetryReadings, 2, 7);
        
        // Output: only the [2,7) range is sorted
        System.out.println(Arrays.toString(telemetryReadings));
    }
}

Descending Order: The One Line That Bites Everyone

Java's Arrays.sort() sorts ascending. That's it. No overload for descending. You want descending order on primitives? You code it yourself. For Integer[] or any object array, you pass a Comparator.reverseOrder() — but that returns null on primitives and burns you at compile time. The real move? For small arrays, write a one-liner after sorting: reverse the array in-place with a simple swap loop. For large arrays or hot paths, use Arrays.parallelSort() with a custom comparator for objects, or sort ascending then reverse. The Collections.reverseOrder() trick works only on object wrappers. Boxing a million ints just to sort them descending? That's how you get a 3AM pager from SRE. If you must sort primitives descending, consider using Arrays.stream(yourArray).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray() — but benchmark it first. Stream overhead can slaughter throughput. Know your data size before choosing the weapon.

// io.thecodeforge — java tutorial

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

public class DescendingSortDemo {
    public static void main(String[] args) {
        // Object array — works
        Integer[] scores = {88, 42, 99, 13, 55};
        Arrays.sort(scores, Collections.reverseOrder());
        System.out.println(Arrays.toString(scores));
        
        // Primitive array — must manual reverse
        int[] rawScores = {88, 42, 99, 13, 55};
        Arrays.sort(rawScores);
        for (int i = 0; i < rawScores.length / 2; i++) {
            int swap = rawScores[i];
            rawScores[i] = rawScores[rawScores.length - 1 - i];
            rawScores[rawScores.length - 1 - i] = swap;
        }
        System.out.println(Arrays.toString(rawScores));
    }
}

Why Array Initialization Is Where Most Devs Waste Memory

You're not just dumping data into a variable. An array in Java is a fixed-size block of memory, and how you create it dictates your production footprint. The 'new' keyword allocates the array object with default values (zeros, nulls) before you touch a single element. That means a 10,000-element int array costs you 40KB the moment you declare it — not when you fill it.

Accessing arrays is O(1) with bracket syntax, but null references in object arrays will crash your pipeline. Always initialize with literal syntax when you know the values at compile time — it's cleaner and avoids the default-initialization step. For dynamic sizes, use new int[n] and loop. There's no dynamic resizing; if you need that, you're looking for ArrayList, but that comes with boxing overhead and a different memory profile. Choose based on what your production loop actually does.

// io.thecodeforge — java tutorial

public class ArrayInitExample {
    public static void main(String[] args) {
        // Literal initialization — compile-time known values
        int[] scores = {95, 82, 74, 91, 88};

        // Dynamic allocation — defaults to zero
        int[] buffer = new int[1000];
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = i * 2;
        }

        // Accessing — O(1), watch bounds
        System.out.println("First score: " + scores[0]);
        System.out.println("Last buffer: " + buffer[buffer.length - 1]);

        // Common rookie mistake — null object array
        String[] names = new String[3];
        // names[0].toUpperCase(); // NullPointerException here
    }
}

Multidimensional Arrays Are Just Jagged Rows — Stop Wiring Them Square

Java doesn't have true 2D arrays. What you get is an array of references to other arrays — each row can be a different length. That's not a bug, it's a feature. A rectangular matrix wastes memory when one dimension is sparse. A jagged array lets you allocate exactly what each row needs, like storing customer orders where order sizes vary.

Access pattern: matrix[row][col] — but remember, each matrix[row] is itself an array. Traversing row-first is cache-friendly because you access contiguous memory within each sub-array. Col-first traversal jumps between sub-array references, thrashing the cache. In production loops with millions of iterations, this is the difference between milliseconds and seconds.

Initialization with double brace syntax looks clever but creates anonymous inner classes — don't do it in production. Use nested loops. And for the love of your team, never use int[][] arr = new int[5][]; without also allocating each row. That's a segfault waiting to happen.

// io.thecodeforge — java tutorial

public class JaggedArrayExample {
    public static void main(String[] args) {
        // Jagged array: each row has different length
        int[][] orders = new int[3][];
        orders[0] = new int[]{101, 202};
        orders[1] = new int[]{303, 404, 505};
        orders[2] = new int[]{606};

        // Row-first traversal — cache friendly
        for (int row = 0; row < orders.length; row++) {
            for (int col = 0; col < orders[row].length; col++) {
                System.out.print(orders[row][col] + " ");
            }
            System.out.println();
        }

        // This compiles but throws at runtime
        // int[][] bad = new int[5][];
        // System.out.println(bad[0][0]); // NullPointerException
    }
}

Tips and Best Practices

Sorting arrays in Java looks easy, but production code breaks when assumptions fail. First, never sort unmodified arrays in place unless you own the data—use Arrays.copyOf() first to avoid mutating caller's state. Second, Arrays.sort() on primitive arrays uses Dual-Pivot Quicksort, which is O(n log n) average but O(n²) worst-case; if you need guaranteed performance, use Arrays.parallelSort() on large datasets (above ~8K elements) to leverage ForkJoinPool. Third, when sorting objects, TimSort is stable (preserves equal-element order) while Quicksort is not—choose based on whether stability matters. Fourth, prefer Comparator.comparing() chains over anonymous classes for readability. Fifth, avoid sorting null-containing arrays without a null-safe comparator (Comparator.nullsLast()). Finally, measure before optimizing: sorting small arrays with Stream.sorted() adds boxing overhead on primitives—stick with Arrays.sort() for int[], double[], etc.

// io.thecodeforge — java tutorial

import java.util.*;

public class SortBestPractices {
    public static void main(String[] args) {
        String[] names = {"Zoe", "alice", "Bob", null};

        // Avoid mutation of original
        String[] sorted = Arrays.copyOf(names, names.length);
        Arrays.sort(sorted, Comparator.nullsLast(
            Comparator.comparing(String::toLowerCase)));

        System.out.println("Original: " + Arrays.toString(names));
        System.out.println("Sorted: " + Arrays.toString(sorted));
        
        // Use parallelSort for large arrays
        int[] big = new int[100_000];
        Arrays.parallelSort(big);  // Faster than sort() on multi-core
    }
}

Learn Java Essentials

Sorting arrays is a core Java skill that forces you to understand four fundamentals. First, mutability: Arrays.sort() modifies the array, Stream.sorted() returns a new one. Choosing wrong corrupts shared state. Second, both Comparable (natural ordering via compareTo()) and Comparator (external ordering) rely on the same contract: consistent with equals, transitive, and throwing NullPointerException on nulls. Third, generics: Arrays.<T>sort() works on object arrays but not primitives—autoboxing helps with List<Integer> but not int[]. Fourth, method references and lambdas: Arrays.sort(arr, (a,b) -> b - a) hides overflow bugs; instead use Comparator.reverseOrder(). These concepts build into streams, optionals, and functional interfaces. Without them, you'll write fragile sorting logic that breaks on edge cases like duplicates, nulls, or large datasets. Master these essentials and sorting becomes a predictable tool, not a guessing game.

// io.thecodeforge — java tutorial

import java.util.*;

public class SortEssentials {
    public static void main(String[] args) {
        // Primitive array — mutable, fast
        int[] nums = {5, 1, 3};
        Arrays.sort(nums);  // modifies in place
        System.out.println("Mutable: " + Arrays.toString(nums));

        // Object array — immutable via stream
        String[] words = {"x", "a", "m"};
        String[] sorted = Arrays.stream(words)
            .sorted()
            .toArray(String[]::new);
        System.out.println("Original: " + Arrays.toString(words));
        System.out.println("New: " + Arrays.toString(sorted));

        // Comparator with null safety
        Arrays.sort(words, Comparator.nullsLast(Comparator.naturalOrder()));
    }
}