Forem: Gabriel Menezes da Silva

Melhorando a performance em Kotlin com concatenação de strings

Gabriel Menezes da Silva — Tue, 07 Oct 2025 21:13:30 +0000

Contexto

Trabalhei em um aplicativo mobile nativo para Android utilizado por uma empresa de logística. Esse app é usado por operadores para escanear etiquetas de pacotes e contêineres, a fim de realizar as etapas necessárias no sistema para classificá-los e ordená-los.

Existe uma função responsável por receber a string, manipulá-las e enviar para o back-end a string correta para que ela seja processada.

Essa função é o coração de todo o aplicativo — sem ela, o processo logístico não funcionaria. Portanto, qualquer melhoria nela é sempre muito bem-vinda.

Neste artigo, será explicado quais melhorias foram feitas e os motivos por trás da implementação.

Qual foi a melhoria feita?

Uma operação executada inúmeras vezes dentro dessa função é a concatenação de strings.

Você pode estar se perguntando: por que melhorar a concatenação é importante?

Dependendo de como ela é feita, você literalmente pode ter problemas de desempenho e uso excessivo de memória para obter o resultado final.

O problema

Antes da melhoria, a concatenação das strings era feita da seguinte forma, usando o famoso operador +=, muito comum no dia a dia dos programadores Kotlin:

var result = ""
val iterations = 1000
for (i in 0 until iterations) {
    result += "Item $i "
}

Ok, mas qual é o problema de usar o +=?

A classe String é imutável, ou seja, a cada iteração uma nova instância de String é criada, e mais memória é alocada.

Em outras palavras, quanto maior o número de iterações, mais memória é usada e mais tempo é necessário para obter o resultado final!

A solução

Usar o StringBuilder em vez do operador +=.

Os motivos são simples:

1. StringBuilder é mutável, ou seja, nenhuma nova instância de string é criada a cada iteração.
2. A mesma alocação de memória é usada durante todo o processo de concatenação.

O código ficaria da seguinte forma:

val result = buildString {
    for (i in 0 until iterations) {
        append("Item $i ")
    }
}

A função buildString utiliza internamente o StringBuilder.
Para referência, veja a documentação oficial do Kotlin.

Exemplo prático

import kotlin.system.measureTimeMillis

fun main() {
    val iterations = 1000

    // Usando +=
    val timePlusEqual = measureTimeMillis {
        var result = ""
        for (i in 0 until iterations) {
            result += "Item $i "
        }
    }

    // Usando buildString (internamente usa StringBuilder)
    val timeBuildString = measureTimeMillis {
        val result = buildString {
            for (i in 0 until iterations) {
                append("Item $i ")
            }
        }
    }

    println("Tempo com +=: ${timePlusEqual}ms")
    println("Tempo com buildString: ${timeBuildString}ms")
}

E o resultado será uma grande diferença:

Tempo com +=: 21ms

Tempo com buildString: 0ms

Neste artigo foi mostrado apenas um exemplo simples, mas imagine isso em larga escala, com strings enormes — o tempo de execução e o consumo de memória aumentariam consideravelmente.

Conclusão

Muitas vezes pensamos que, para causar um grande impacto em um projeto, é preciso fazer algo gigantesco — como mudar toda a arquitetura do aplicativo.

Mas isso não é verdade.
Pequenas melhorias podem gerar um impacto enorme e entregar valor real aos clientes.
Ter isso em mente traz uma sensação de conforto: saber que otimizações simples também fazem a diferença.

Improving performance in Kotlin with string concatenation

Gabriel Menezes da Silva — Wed, 01 Oct 2025 21:31:21 +0000

Context

I worked in a native android mobile application used by a logistic company. This app is used by operators to scan the labels of packages/containers in order to do the steps necessary in the system to sort them.

There's a function where it gets the label string/bytes, manipulates it and delivers to the back-end the correct string so they can process it.

This function is the heartbeat of the whole application, without it, the logistics will not work, so every improvement in it, it's always welcomed.

In this article, It will be explained which improvements were done and the reasons why they were implemented.

Which improvement was done?

A operation that is done numerous times in this function is the concatenation.

You might be asking, but why improving the concatenation is important? Depending on the concatenation that is being done, you literally can have problems of memory and time to get the result.

Problem

So before the improvement, the concatenation of the strings was being done like described in the code below, using the famous += operator, very commonly used in the daily basis:

 var result = ""
   val iterations = 1000
   for (i in 0 until iterations) {
       result += "Item $i "
  }

Ok, but what's the problem of using it?:

String is a immutable object, that is, in every iteration a new instance of String is created, more memory is allocated.

That is, the more you increase the number of iterations, more memory is allocated and more time will be taken to get the result!!

Solution

Use StringBuilder instead of using the operator +=. The reasons why will be described below:

StringBuilder is a mutable object, that is, no new instance of string is created in every iteration.
The same memory allocation is used for all the concatenation process, all the iteration.

The following code shows how this could be implemented:

  val result = buildString {
            for (i in 0 until iterations) {
                append("Item $i ")
            }
        }

buildString uses StringBuilder under the hood. For reference checkout this kotlin doc link.

If you run the following code:

/**
 * You can edit, run, and share this code.
 * play.kotlinlang.org
 */
import kotlin.system.measureTimeMillis
fun main() {
  val iterations = 1000


    val timePlusEqual = measureTimeMillis {
        var result = ""
        for (i in 0 until iterations) {
            result += "Item $i "
        }
    }

    // StringBuilder
    // Kotlin is under the hood using a StringBuilder, 
    val timeBuildString = measureTimeMillis {
        val result = buildString {
            for (i in 0 until iterations) {
                append("Item $i ")
            }
        }
    }

    println("Time with +=: ${timePlusEqual}ms")
    println("Time with buildString: ${timeBuildString}ms")
}

You'll get this BIG difference:

Time with +=: 21ms
Time with buildString: 0ms

In this article I'm just writing a simple example, but imagine this in a big scale, with very big strings, this time difference and memory will increase.

Conclusion

Sometimes we think that to create huge impact in a project, It's necessary to do big things like changing the architecture of the whole app.
That's not true, simple things can bring huge impact and deliver real good value for the clients. It's necessary to have that in our minds, It creates a feeling of comfort.