Array Sorting in Java: Arrays.sort() Explained From Scratch

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 of this article 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.

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.

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.

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)");
        }
    }
}

Frequently Asked Questions