Is there a shorter replacement for Kotlin's deprecated String.capitalize() function?

The suggested replacement is ugly because it needs to be equivalent to what capitalize() used to do:

1. dependent on the default locale
2. NOT converting an uppercase first char into titlecase (e.g. capitalize does NOT transform a leading 'DŽ' into 'Dž' - both are single characters here, try to select them)

If you didn't care too much about this behaviour, you can use a simpler expression using an invariant locale and unconditionally titlecasing the first character even if uppercase:

val x = listOf("foo", "bar", "baz").map { it.replaceFirstChar(Char::titlecase) }

This means that if the first character is uppercase like 'DŽ', it will be transformed into the titlecase variant 'Dž' anyway, while the original code wouldn't touch it. This might actually be desirable.

One of the reasons capitalize() has been deprecated is because the behaviour of the method was unclear. For instance:

• behaviour #2 is pretty weird
• not capitalizing words in a sentence might be unexpected (C# would titlecase every space-separated word)
• not lowercasing other characters of the words might be unexpected as well

If you want to keep the exact current behaviour on purpose, but make it more convenient to use, you can always roll your own extension function with a name that suits you ("capitalize(d)" might not give enough info to the unaware reader):

fun String.titlecaseFirstCharIfItIsLowercase() = replaceFirstChar { 
    if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() 
}

Or for the version with invariant locale that titlecases the uppercase chars:

fun String.titlecaseFirstChar() = replaceFirstChar(Char::titlecase)

A neat solution is to define a new extension function on String, which hides the gory details with a cleaner name:

/**
 * Replacement for Kotlin's deprecated `capitalize()` function.
 */
fun String.capitalized(): String {
    return this.replaceFirstChar { 
        if (it.isLowerCase())
            it.titlecase(Locale.getDefault())
        else it.toString() 
    }
}

Now your old code can look like this:

val x = listOf("foo", "bar", "baz").map { it.capitalized() }

You'll need to define the extension function at the top level in some package that you can import easily. For example, if you have a kotlin file called my.package.KotlinUtils (KotlinUtils.kt), and you put the definition inside it like so:

package my.package

fun String.capitalized(): String {...}

Then you can import it in your other packages with:

import my.package.capitalized

val fruits = listOf("baNana", "avocAdo", "apPle", "kiwifRuit")
fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.lowercase().replaceFirstChar(Char::uppercase) }
    .forEach { println(it) }

Output:

Apple
Avocado

You can call the replaceFirstChar function on the original string and pass the transform function as input. The transform function takes the first character and converts it to an uppercase character using the uppercase() function.

val list = listOf("foo", "bar", "baz") .map {
     it.replaceFirstChar { firstChar ->
          firstChar.uppercase()
     }
 }
println("List - > $list")

Output

List - > [Foo, Bar, Baz]

How about this?

fun main() {
    val x = listOf("foo", "bar", "baz").map { it[0].uppercase() + it.drop(1) }
    println(x)
}

Output:

[Foo, Bar, Baz]

If you are not sure (maybe you receive Strings from an API) if the first letter is upper or lower case , you can use the below method;

var title = "myTitle"
title.replaceFirstChar {
        if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else 
        it.toString()
    }

New title will be "MyTitle"

You can use this extension function to capitalize first characture of String

fun String.capitalize(): String {
        return this.replaceFirstChar {
            if (it.isLowerCase()) it.titlecase(Locale.getDefault())
            else it.toString()
        }
}

And call this method like

"abcd".capitalize()