Sort a list of strings by length: ascending and descending using streams

• comparingInt(String::length) extracts the string's length as a primitive int and sorts ascending (shortest first).
• .reversed() reverses the comparator to sort descending (longest first).
• thenComparing(Comparator.naturalOrder()) adds alphabetical ordering as a tiebreaker when two strings have the same length.
• comparingInt is preferred over comparing(String::length) because it avoids autoboxing int to Integer for each comparison.
• The result is a new sorted list; the original list is not modified.

What does sorting by length mean?

Sorting strings by length orders them from shortest to longest (ascending) or longest to shortest (descending). The string's content does not matter for ordering, only its character count.

How do you sort ascending by length?

package com.bank.analytics;

import java.util.*;

public class StringLengthSortDemo {
    public static void main(String[] args) {
        List<String> symbols = List.of(
            "RELIANCE", "TCS", "HDFC", "INFY", "SBI", "WIPRO");

        // Ascending by length (shortest first)
        List<String> asc = symbols.stream()
            .sorted(Comparator.comparingInt(String::length))
            .toList();

        System.out.println("Ascending: " + asc);
    }
}

Ascending: [TCS, SBI, HDFC, INFY, WIPRO, RELIANCE]

How do you sort descending by length?

// Descending by length (longest first)
List<String> desc = symbols.stream()
    .sorted(Comparator.comparingInt(String::length).reversed())
    .toList();

System.out.println("Descending: " + desc);

Descending: [RELIANCE, WIPRO, HDFC, INFY, TCS, SBI]

How do you add a tiebreaker for equal lengths?

When two strings have the same length, their relative order is undefined without a tiebreaker. Add thenComparing(Comparator.naturalOrder()) for alphabetical tiebreak.

// Length ascending, then alphabetical for equal lengths
List<String> withTiebreak = symbols.stream()
    .sorted(Comparator.comparingInt(String::length)
        .thenComparing(Comparator.naturalOrder()))
    .toList();

System.out.println("With tiebreak: " + withTiebreak);

With tiebreak: [SBI, TCS, HDFC, INFY, WIPRO, RELIANCE]

SBI comes before TCS (both length 3, alphabetical). HDFC comes before INFY (both length 4, alphabetical).

How is comparingInt different from comparing for length?

| Method | Autoboxing | Performance |
|--------|-----------|-------------|
| comparingInt(String::length) | No autoboxing | Faster for large lists |
| comparing(String::length) | Boxes int to Integer each comparison | Slower |

// WRONG (works but wasteful): comparing boxes int to Integer
Comparator<String> slow = Comparator.comparing(String::length);

// CORRECT (efficient): comparingInt uses primitive int
Comparator<String> fast = Comparator.comparingInt(String::length);

What are common mistakes?

WRONG: Using reversed() after thenComparing to reverse only the length.

// WRONG: reversed() reverses BOTH length and alphabetical
Comparator<String> wrong = Comparator.comparingInt(String::length)
    .thenComparing(Comparator.naturalOrder())
    .reversed();  // length is now DESC and alphabetical is now Z-A!

CORRECT: Reverse only the length comparator before adding the tiebreaker.

// CORRECT: length descending, alphabetical ascending
Comparator<String> correct = Comparator.comparingInt(String::length).reversed()
    .thenComparing(Comparator.naturalOrder());

What about case-insensitive length sorting?

// Sort branch names by length, case-insensitive tiebreak
List<String> branches = List.of("Mumbai", "delhi", "Pune", "KOLKATA");

List<String> sorted = branches.stream()
    .sorted(Comparator.comparingInt(String::length)
        .thenComparing(String.CASE_INSENSITIVE_ORDER))
    .toList();
// [Pune, delhi, Mumbai, KOLKATA]

What should a senior engineer know?

• comparingInt, comparingLong, and comparingDouble avoid autoboxing and are always preferred over comparing for primitive fields.
• The sorted() operation is stable (TimSort), so equal-length strings maintain their original order even without an explicit tiebreaker. But relying on stability makes code fragile and non-obvious.
• For very large lists, sorted() buffers all elements in memory. Consider whether you need only the top-N shortest strings (sorted().limit(n)) which can optimize internally.