Kotlin – String formatting

Question

Kotlin has an excellent feature called string templates.

val i = 10 
val s = "i = $i" // evaluates to "i = 10"

But is it possible to have any formatting in the templates? For example, I would like to format Double in string templates in kotlin, at least to set a number of digits after a decimal separator:

val pi = 3.14159265358979323
val s = "pi = $pi??" // How to make it "pi = 3.14"?

Answer 1

Unfortunately, there's no built-in support for formatting in string templates yet, as a workaround, you can use something like:

"pi = ${pi.format(2)}"

the .format(n) function you'd need to define yourself as

fun Double.format(digits: Int) = "%.${digits}f".format(this)

This will work only in Kotlin/JVM.

There's clearly a piece of functionality here that is missing from Kotlin at the moment, we'll fix it.

Answer 2

As a workaround, There is a Kotlin stdlib function that can be used in a nice way and fully compatible with Java's String format (it's only a wrapper around Java's String.format())

See Kotlin's documentation

Your code would be:

val pi = 3.14159265358979323
val s = "pi = %.2f".format(pi)

Answer 3

Kotlin's String class has a format function now, which internally uses Java's String.format method:

/**
 * Uses this string as a format string and returns a string obtained by substituting the specified arguments,
 * using the default locale.
 */
@kotlin.internal.InlineOnly
public inline fun String.Companion.format(format: String, vararg args: Any?): String = java.lang.String.format(format, *args)

Usage

val pi = 3.14159265358979323
val formatted = String.format("%.2f", pi) ;
println(formatted)
>>3.14

Answer 4

It's simple, use:

val str: String = "%.2f".format(3.14159)

Answer 5

Since String.format is only an extension function (see here) which internally calls java.lang.String.format you could write your own extension function using Java's DecimalFormat if you need more flexibility:

fun Double.format(fracDigits: Int): String {
    val df = DecimalFormat()
    df.setMaximumFractionDigits(fracDigits)
    return df.format(this)
}

println(3.14159.format(2)) // 3.14

Answer 6

A couple of examples:

infix fun Double.f(fmt: String) = "%$fmt".format(this)
infix fun Double.f(fmt: Float) = "%${if (fmt < 1) fmt + 1 else fmt}f".format(this)

val pi = 3.14159265358979323

println("""pi = ${pi f ".2f"}""")
println("pi = ${pi f .2f}")

Answer 7

Kotlin 1.7.2

String's format method takes in a formatter-string and any number of args in nullable Any type.

fun String.Companion.format(format: String, vararg args: Any?) : String

Real code may look like this:

fun main() {
    
    val pi: Double = 3.141592653589
    val gravity: Double = 9.80665
    var str = String.Companion.format("%.2f %n%.2f", pi, gravity)
    
    println(str)
}

Where %n is a line separator, and %f is Float in Decimal Format.

Results are:

//    3.14 
//    9.81

Answer 8

It has string formatting Example in Kotlin for Android TextView:

val format = String.format("<font color=#3177a3> test1: <b>%s</b><br> test2: <b>%s</b><br> test3: <b>%s</b></font>", "value1", "value2", "value3")
textView.text = format

Answer 9

As a workaround simple solution for multiplatform you can use:

import kotlin.math.abs
import kotlin.math.pow

fun Number.simpleFormat(numberDigitsAfterSeparator: Int = 0, decimalSeparator: Char = ','): String {
    if(numberDigitsAfterSeparator < 0)
        throw IllegalArgumentException("numberDigitsAfterSeparator should be >= 0 but is $numberDigitsAfterSeparator")

    val prefix = this.toInt()
    if(numberDigitsAfterSeparator == 0)return "$prefix"

    val sign = if(this.toDouble() >= 0.0) "" else "-"

    val afterSeparatorPart = abs(this.toDouble() - prefix)
    val suffixInt = (10.0.pow(numberDigitsAfterSeparator) * afterSeparatorPart).toInt()
    val suffix = if(afterSeparatorPart >= 1.0) "$suffixInt" else addNullsBefore(suffixInt, numberDigitsAfterSeparator)
    return "$sign${abs(prefix)}$decimalSeparator$suffix"
}

fun addNullsBefore(suffixInt: Int, numberDigitsAfterSeparator: Int): String {
    var s = "$suffixInt"
    val len = s.length
    repeat(numberDigitsAfterSeparator - len) { _ -> s = "0$s" }
    return s
}

Test:

fun main() {


    println((-0.00001).simpleFormat(5))
    println(3.1415927.simpleFormat(2))
    println(3.99.simpleFormat(2))
    println((-3.99).simpleFormat(2))

    println(3.1415927.simpleFormat())
    println(3.99.simpleFormat())
    println((-3.99).simpleFormat())

    println((-3.99).simpleFormat(-1))
}

wiht output:

-0,00001
3,14
3,99
-3,99
3
3
-3
Exception in thread "main" java.lang.IllegalArgumentException: numberDigitsAfterSeparator should be >= 0 but is -1..

Answer 10

It has string formatting Example:

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}