Sort an Array of Strings According to String Lengths

1. Overview

In this tutorial, we’ll explore different approaches to sorting a string array according to the element’s length.

2. Comparator

When we work on sorting in Java, we often define a Comparator that returns the order between two arguments. The sorting algorithm applies the sort order generated by the Comparator and returns the sorted result.

When defining a Comparator, we implement the following method:

int compare(T o1, T o2);

According to the Java API, this method must return a negative value if o1 is smaller than o2, zero if both are equal or a positive value if o1 is greater than o2.

In our examples in the latter sections, we’ll use this unsorted string array for illustration purposes:

String[] inputArray = new String[] {"am", "today", "too", "I", "busy"};

We expect the following array when inputArray is sorted by the string length:

String[] SORTED = new String[] {"I", "am", "too", "busy", "today"};

3. Comparison by Custom Comparator

The most trivial way is to define a custom string Comparator that compares numerically based on the string length:

public class StringLengthComparator implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
}

We’ll call Array.sort() for sorting an array. In our case, we must provide the second argument, our custom comparator. Otherwise, the sorting will be based on the natural ordering:

@Test
void whenSortByCustomComparator_thenArraySorted() {
    StringLengthComparator comparator = new StringLengthComparator();
    Arrays.sort(inputArray, comparator);
    assertThat(inputArray).isEqualTo(SORTED);
}

Depending on our need, we could define an anonymous class instead of a separate class if the Comparator is for one-off usage:

@Test
void whenSortByInnerClassComparator_thenArraySorted() {
    Arrays.sort(inputArray, new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            return Integer.compare(s1.length(), s2.length());
        }
    });
    assertThat(inputArray).isEqualTo(SORTED);
}

4. Comparison by Lambda Expression

Since Java 8 introduced lambda expression, we can simplify the previous approach by supplying the lambda expression rather than using an anonymous class. A lambda is an anonymous function that can be passed around as an object.

With lambda expression, we can pass the comparison function to Array.sort() as the second argument, without explicitly defining any class. This highly improves the readability of the code:

@Test
void whenSortedByLambda_thenArraySorted() {
    Arrays.sort(inputArray, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
    assertThat(inputArray).isEqualTo(SORTED);
}

The example does the same as in the previous section. It’s just much neater when we define it using lambda expression.

5. Comparison by Comparing Function

Java 8 also introduced convenient comparison static functions in the Comparator class.

Comparator.comparingInt() is the one that we can adopt here. This static function accepts a method reference that returns an integer. For the following example, we’ll apply String::length as the method reference that obtains the length of the string:

@Test
void whenSortedByComparingInt_thenArraySorted() {
    Arrays.sort(inputArray, Comparator.comparingInt(String::length));
    assertThat(inputArray).isEqualTo(SORTED);
}

Again, this does the same as the previous one with an even more simplified syntax.

6. Conclusion

In this article, we explored different approaches to sorting. It’s based on supplying to Array.sort() a dedicated Comparator that sorts an array of strings based on their lengths.

The Comparator can be created from a custom Comparator class, a lambda expression, or a comparing function.