Clonando listas em Kotlin: cópia profunda vs superficial

Clonagem de listas em Kotlin: como não se complicar com referências?

Imagine: você está escrevendo um aplicativo em Kotlin, processando uma lista de dados, e de repente o array original muda sozinho. Essa dor é familiar? Provavelmente, você apenas copiou a referência, e não a lista em si. Neste artigo, vamos explorar todas as formas legais de clonar uma lista em Kotlin — desde a cópia superficial até a profunda. Sem enrolação, apenas código e explicações.

O tema foi inspirado por uma pergunta popular no Stack Overflow (mais de 200.000 visualizações): "How to clone or copy a list in kotlin". Vamos entender de uma vez por todas como copiar uma lista Kotlin corretamente, para não perder dados e não enlouquecer.

Por que a simples atribuição não funciona?

Em Kotlin, assim como em Java, listas são tipos por referência. Se você escrever:

val original = mutableListOf("A", "B", "C")\nval copy = original  // Isso NÃO é uma cópia!\ncopy.add("D")\nprintln(original) // [A, B, C, D] — o original mudou!

Você apenas criou uma segunda referência para o mesmo objeto na memória. Qualquer alteração através de copy afetará original. Para evitar isso, é necessário usar métodos especiais de cópia de lista em Kotlin.

Top 5 formas de copiar uma lista em Kotlin

Vamos explorar todas as principais opções: desde o simples toList() até a cópia profunda manual. Escolha a mais adequada para sua tarefa.

1. toList() — a forma mais simples

O método toList() cria uma nova cópia imutável da lista. Isso é uma cópia superficial (shallow copy) — os elementos em si não são duplicados, mas a estrutura da lista se torna independente.

val original = listOf("Kotlin", "Java", "Python")\nval copy = original.toList()\n\n// copy é um novo objeto\nprintln(copy === original) // false — referências diferentes\nprintln(copy == original)  // true — mesmo conteúdo

Ideal para listas simples de strings ou números. Se você precisar de uma cópia mutável, use toMutableList().

2. toMutableList() — para cópias mutáveis

Quer uma cópia que possa ser modificada? toMutableList() é a sua escolha. Ele cria um novo MutableList com os mesmos elementos.

val original = listOf(1, 2, 3)\nval mutableCopy = original.toMutableList()\nmutableCopy.add(4)\n\nprintln(original)       // [1, 2, 3]\nprintln(mutableCopy)    // [1, 2, 3, 4] — o original não foi alterado

Esta é a forma mais popular de clonar uma mutable list em Kotlin.

3. ArrayList(collection) — o clássico do Java

Se você vem do Java, esta forma parecerá familiar. O construtor ArrayList recebe outra coleção e copia seus elementos.

val original = listOf("A", "B", "C")\nval arrayCopy = ArrayList(original)\narrayCopy[0] = "Z"\n\nprintln(original)    // [A, B, C]\nprintln(arrayCopy)   // [Z, B, C]

Funciona de forma rápida e previsível. Mas lembre-se: também é uma shallow copy.

4. map() — com transformação de elementos

Se você precisa não apenas copiar, mas também transformar os elementos, use map(). Ele cria uma nova lista com base na antiga, aplicando uma lambda a cada elemento.

val numbers = listOf(10, 20, 30)\nval doubled = numbers.map { it * 2 }\n\nprintln(numbers)  // [10, 20, 30]\nprintln(doubled)  // [20, 40, 60]

Para uma cópia simples sem alterações, você pode escrever numbers.map { it }, mas isso é redundante — é melhor usar toList().

5. Cópia profunda (deep copy) para objetos complexos

Todos os métodos anteriores fazem cópia superficial. Se sua lista contém objetos mutáveis (por exemplo, data class com campos), a alteração do objeto na cópia afetará o original: