Sorting an Array of Strings Based on Length in Kotlin: A Complete Guide

Programming frequently involves sorting an array of strings according to their length, particularly when working with text data that needs to be arranged according to its dimensions. With its strong features and contemporary syntax, Kotlin offers several ways to accomplish this. This blog post will cover handling null values, sorting strings by length in both ascending and descending order, and using custom comparators for more complex sorting logic.

1. Arrays and Sorting in Kotlin

An array in Kotlin is a collection of elements that stores data of the same type. Sorting strings based on their length involves comparing the length of each string to determine their relative order.

Example of a String Array

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

Here, words is an Array<String> containing strings of varying lengths.

2. Sorting Strings by Length in Ascending Order

Using sortWith and a Custom Comparator

Kotlin’s sortWith function allows us to define custom sorting logic.

Example:

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

words.sortWith(compareBy { it.length })
println(words.joinToString())  // Output: kiwi, apple, banana, cherry, watermelon

Using sortedBy

The sortedBy function creates a new list sorted by the specified criteria.

Example:

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

val sortedWords = words.sortedBy { it.length }
println(sortedWords)  // Output: [kiwi, apple, banana, cherry, watermelon]

3. Sorting Strings by Length in Descending Order

Using sortWith and compareByDescending

For descending order, use compareByDescending with sortWith.

Example:

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

words.sortWith(compareByDescending { it.length })
println(words.joinToString())  // Output: watermelon, banana, cherry, apple, kiwi

Using sortedByDescending

The sortedByDescending function creates a new list sorted in reverse order.

Example:

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

val sortedWords = words.sortedByDescending { it.length }
println(sortedWords)  // Output: [watermelon, banana, cherry, apple, kiwi]

4. Handling Null Values During Sorting

Kotlin arrays can contain null values, which can complicate sorting. Use nullsFirst or nullsLast to manage nulls effectively.

Nulls First Example

val words = arrayOf("banana", null, "kiwi", "cherry", "watermelon")

words.sortWith(compareBy(nullsFirst()) { it?.length })
println(words.joinToString())  // Output: null, kiwi, banana, cherry, watermelon

Nulls Last Example

words.sortWith(compareBy(nullsLast()) { it?.length })
println(words.joinToString())  // Output: kiwi, banana, cherry, watermelon, null

5. Sorting with Lambda Expressions

Kotlin’s lambda syntax allows concise custom sorting.

Lambda Example

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

words.sortWith { a, b -> a.length.compareTo(b.length) }
println(words.joinToString())  // Output: kiwi, apple, banana, cherry, watermelon

For descending order:

words.sortWith { a, b -> b.length.compareTo(a.length) }
println(words.joinToString())  // Output: watermelon, banana, cherry, apple, kiwi

6. Sorting Immutable Arrays

Kotlin provides immutable collections, and sorting such arrays requires creating new collections.

Using toList and sortedBy

val words = arrayOf("banana", "apple", "kiwi", "cherry", "watermelon")

val sortedImmutable = words.toList().sortedBy { it.length }
println(sortedImmutable)  // Output: [kiwi, apple, banana, cherry, watermelon]

7. Combining Multiple Criteria

You can sort strings by multiple criteria using chained comparators.

Sort by Length, then Alphabetically

val words = arrayOf("banana", "apple", "kiwi", "cherry", "date")

words.sortWith(compareBy<String> { it.length }.thenBy { it })
println(words.joinToString())  // Output: date, kiwi, apple, banana, cherry

Sort by Length, then Reverse Alphabetically

words.sortWith(compareBy<String> { it.length }.thenByDescending { it })
println(words.joinToString())  // Output: kiwi, date, cherry, banana, apple

8. Performance Considerations

Sorting performance depends on the size of the array and the complexity of the comparator. Kotlin’s sorting functions are optimized and typically perform well for most use cases.

Time Complexity

• Default Sorting: O(nlog⁡n)O(n \log n)O(nlogn)
• Custom Comparators: Additional complexity based on logic

For large datasets, consider efficiency when designing custom comparators.

9. Real-World Applications

Sorting strings by length has practical applications:

• Displaying words or names in a text editor or application
• Organizing lists based on priority (shorter names first)
• Preparing data for natural language processing (NLP) tasks

Example: Sorting Usernames by Length

val usernames = arrayOf("Anna", "Christopher", "Bill", "Kate", "Alexander")

usernames.sortWith(compareBy { it.length })
println(usernames.joinToString())  // Output: Anna, Bill, Kate, Alexander, Christopher

10. Conclusion

Sorting an array of strings by length in Kotlin is straightforward and flexible, thanks to Kotlin’s powerful standard library. From basic sorting to handling nulls and using custom logic, Kotlin offers a range of options to suit your needs. Whether you’re organizing data for display or preparing it for further processing, mastering these sorting techniques will make your Kotlin programming more effective.