CodeGym /Cursos /Kotlin SELF /Tuplas: Pair e Triple

Tuplas: Pair e Triple

Kotlin SELF
Nível 10, Lição 1
Disponível

1. Como retornar varios valores de uma funcao?

Se voce esta apenas comecando a programar, e muito facil pensar: “Bom, se eu preciso retornar dois valores — eu simplesmente… retorno dois valores”. Infelizmente, a maioria das linguagens (e Kotlin inclusive) normalmente exige que uma funcao retorne exatamente um valor.

Para esse caso, os programadores tem um truque: retornar nao “dois valores”, mas um conteiner, dentro do qual estao dois valores. E e exatamente aqui que, em Kotlin, entram Pair e Triple.

Imagine uma caixa com um adesivo: “Dentro ha duas coisas”. Isso e Pair. E uma caixa “Dentro ha tres coisas” — isso e Triple. O Kotlin fornece essas caixas prontas (desculpe o trocadilho), para que voce nao reinvente a roda e nao cole os dados numa string do tipo "10,20".

Pair: conteiner de dois valores

Pair e um tipo padrao do Kotlin que armazena exatamente dois valores relacionados. Relacionados mesmo: ou seja, valores que fazem sentido juntos. Nao “almondégas e foguetes espaciais”, mas algo como “nome e idade”, “coordenada X e coordenada Y”, “codigo de resposta e texto da mensagem”.

E importante notar que Pair nao impõe significado aos componentes. Ele nao tem campos x e y, nao tem name e age. So existem os honestos e um pouco sem graca first e second. O significado vem do contexto e dos nomes das variaveis ao redor.

Criamos Pair com Pair(a, b) e lemos com first/second

O jeito mais direto: chamar o construtor Pair(...).

fun main() {
    val point = Pair(10, 20)

    println(point.first)   // 10
    println(point.second)  // 20
}

Aqui point e um “ponto”, entao combinamos que first e x, e second e y. O Kotlin nao sabe disso. O Kotlin apenas armazena “o primeiro” e “o segundo”. A combinacao fica por sua conta.

Exemplo mais proximo da realidade: “valor + explicacao”

As vezes e util manter um numero e um texto curto lado a lado — por exemplo, “resultado do calculo + um comentario do que foi isso”.

fun main() {
    val result = Pair(200, "OK")

    println("code=${result.first}")     // code=200
    println("message=${result.second}") // message=OK
}

Repare: ler result.first diz pouca coisa sobre o que esta armazenado ali. Por isso, normalmente ou damos a variavel um nome mais especifico, ou (na proxima aula) vamos desempacotar isso via desestruturacao. Mas hoje treinamos honestamente a leitura dos valores via first/second.

3. Triple: conteiner de tres valores

Triple e o irmao gemeo do Pair, so que ele tem tres valores dentro. Isso e conveniente quando os dados sao realmente tres e formam um unico conjunto de significado. O exemplo classico e RGB: vermelho, verde, azul.

Assim como no Pair, os nomes dos componentes sao sem graca, mas obvios: first, second, third. O Kotlin parece dizer: “Eu so armazeno. O significado e trabalho de voce”.

Criamos Triple e lemos com first/second/third

fun main() {
    val rgb = Triple(255, 128, 0)

    println("r=${rgb.first}")   // r=255
    println("g=${rgb.second}")  // g=128
    println("b=${rgb.third}")   // b=0
}

Cola: como ler os componentes

Quando os olhos cansam de first/second/third, e util ter uma cola simples.

Tipo Quantos valores armazena Como ler os componentes
Pair
2
first, second
Triple
3
first, second, third

4. Criacao conveniente: to e inferencia de tipos

Agora vai ter um pedacinho de “magia do Kotlin”, mas nao tenha medo: a magia aqui e do bem.

Além de Pair(a, b), existe uma notacao super popular:

val range = 1 to 10

Ela cria Pair(1, 10).

Essa forma funciona porque to e uma funcao que o Kotlin permite chamar na forma infix (infixa): quando o nome da funcao fica entre dois valores. O Kotlin descreve as regras das chamadas infixas (a funcao deve ter um parametro e mais alguns requisitos) numa documentacao separada sobre notacao infixa.

a to b e um par, nao um “sintaxe especial”

E importante entender: to nao e “parte da linguagem para pares”, e uma funcao comum (so que e conveniente usa-la na forma infixa). Portanto, a to b e exatamente a criacao de Pair(a, b).

Importante: 1 to 10 nao e o intervalo 1..10

Muito importante: 1 to 10 nao e o intervalo 1..10. E apenas um par de valores, em que first = 1, second = 10.

fun main() {
    val fromTo = 1 to 10

    println("from=${fromTo.first}") // from=1
    println("to=${fromTo.second}")  // to=10
}

De nomes de variaveis “falantes”

A legibilidade de Pair quase sempre depende dos nomes das variaveis. Se voce nomear a variavel bem, o codigo fica visivelmente mais amigavel.

fun main() {
    val minMax = 3 to 12

    println("min=${minMax.first}") // min=3
    println("max=${minMax.second}") // max=12
}

A notacao a to b e tao comum que o Kotlin a usa diretamente em exemplos da documentacao quando e preciso “combinar pares”.

Quais tipos ficam dentro de Pair/Triple

Agora vem um ponto importante: Pair e Triple conseguem armazenar qualquer coisa. Quer Int e String? Sem problema. Quer String e Boolean? Tambem da. E o Kotlin, nesse processo, muitas vezes infere os tipos sozinho, como ja estamos acostumados com variaveis.

Ou seja, se voce escreve val p = 10 to 20, o Kotlin entende que isso e Pair<Int, Int>. Mas hoje nao vamos entrar em detalhes — isso vai ser bem mais tarde. Por enquanto, basta entender a pratica: os tipos dentro do par correspondem ao que voce colocou nele.

Pair de tipos diferentes

fun main() {
    val user = Pair("Ada", 36)

    println(user.first)   // Ada
    println(user.second)  // 36
}

Aqui first e string, second e numero. O Kotlin lida com isso perfeitamente.

Triple — so se for um unico significado, e nao um “saco de tudo”

So lembre: Triple nao e um saco de “o que mais da para enfiar”. Se os tres valores nao formam uma unica ideia, depois voce mesmo vai olhar para isso como um enigma.

fun main() {
    val movie = Triple("Matrix", 1999, true)

    println(movie.first)  // Matrix
    println(movie.second) // 1999
    println(movie.third)  // true
}

Funciona? Sim. E legivel? Mais ou menos. Porque true e “o que”? “Ja assistiu”? “Gostou”? “O filme existe”? E por isso que Pair/Triple devem ser usados com cuidado.

5. Aplicacao: “rascunho de despesas” no console

Para nao deixar Pair e Triple no mundo das pontos e cores abstratas, vamos comecar a desenvolver um pequeno aplicativo de console educativo. Que seja um “rascunho de controle de despesas” super minimalista: o usuario digita a categoria e o valor, e nos imprimimos uma confirmacao clara.

Hoje nossa tarefa e simples: aprender a armazenar um registro de despesa como o conjunto “categoria + valor”. Para isso, Pair e perfeito: dois valores, um significado.

Criamos uma “despesa” como Pair

fun main() {
    val expense = "food" to 250

    println("Category: ${expense.first}") // Category: food
    println("Amount: ${expense.second}")  // Amount: 250
}

Sim, food e 250 poderiam ser armazenados em duas variaveis. Mas a ideia e: as vezes e conveniente passar isso adiante como um unico objeto: “aqui esta a despesa completa”.

Lemos os dados e montamos um Pair

Ja sabemos readln() e toIntOrNull(). Nao vamos complicar: vamos supor que o usuario digita a categoria na primeira linha e o valor na segunda.

fun main() {
    print("Enter category: ")
    val category = readln().trim()

    print("Enter amount: ")
    val amountText = readln().trim()
    val amount = amountText.toInt()

    val expense = category to amount
    println("Saved: ${expense.first} -> ${expense.second}") // exemplo: Saved: food -> 250
}

Isso ainda nao e um controle de despesas “de verdade”, mas como passo de aprendizado — excelente: vimos como Pair vira uma pequena “embalagem” para informacao relacionada.

Quando Pair/Triple fazem sentido e quando e melhor parar

Pair e Triple sao como fita adesiva. E util no dia a dia, mas se voce construiu uma nave espacial so de fita adesiva, talvez tenha deixado passar algo no projeto.

Normalmente Pair/Triple sao adequados quando os valores sao realmente pequenos, sao poucos, e voce entende rapidamente pelo contexto o que significa first e second. Por exemplo, x to y para uma coordenada, min to max para limites, code to message para resultado.

Mas se voce se pega pensando o tempo todo “e o first — e o que mesmo?” e comeca a escrever comentarios do tipo // first = category, second = amount, isso e um sinal: talvez voce precise de um resultado mais “nomeado”. Mas como fazer isso do jeito certo eu vou contar para voce daqui a uns 10 niveis.

7. Erros tipicos ao trabalhar com Pair e Triple

Erro no 1: confusao na ordem dos componentes (first/second).
O problema mais comum e confundir o que esta em first e o que esta em second. Principalmente quando, em diferentes partes do codigo, voce cria pares parecidos, mas “combinou de um jeito diferente”: em um lugar (min, max) e em outro (max, min). Isso nao e um erro do compilador — e um erro de significado. O que salva e disciplina: fixe a ordem e mantenha-a igual em todo lugar, e de nomes as variaveis de forma que sugiram essa ordem (minMax, fromTo, xToY).

Erro no 2: usar Pair para dados nao relacionados “porque da”.
Tecnicamente, voce pode colocar qualquer coisa em Pair. Mas se os dois valores nao formam um unico significado, a leitura vira um quebra-cabeca. Depois de uma semana, voce vai abrir o codigo e vai ficar tentando adivinhar por que val x = pair.first, e o que e esse x afinal? Pair nao e um “pacote para viagem” para sobras aleatorias.

Erro no 3: achar que first significa “o principal”.
As vezes, iniciantes acham que first e o “campo principal” e second e “o adicional”. O Kotlin nao pensa assim. Nao existe principal e secundario, existe apenas a ordem. Se o significado exige “principalidade”, isso precisa ser expresso pelos nomes das variaveis e pela logica do codigo, e nao esperando magia da palavra first.

Erro no 4: Triple como um “saco de tudo”.
Triple vira facilmente um mini-caos: “coloca o nome, a idade, um flag, e… opa, nao tem quarto lugar”. Se voce ja sente que Triple nao comporta um significado real, isso nao e um “Triple ruim”; e um bom sinal de que o modelo de dados pede uma forma mais adequada. Por enquanto, apenas memorize esse sinal — vamos voltar a ele no futuro, quando tivermos nossos proprios tipos.

Erro no 5: cadeias longas de .first.first....
Quando voce comeca a ver construcoes como something.first.second, significa que em algum lugar voce colou um Pair dentro de outro Pair e ja criou um labirinto para si mesmo. Nessa situacao, e melhor parar e colocar os valores intermediarios em variaveis com nomes normais. Mesmo que fique duas linhas mais longo — vai custar menos para o cerebro do que decifrar uma “matrioshka de first’s”.

1
Tarefa
Kotlin SELF, nível 10, lição 1
Bloqueado
Coordenadas no mapa
Coordenadas no mapa
1
Tarefa
Kotlin SELF, nível 10, lição 1
Bloqueado
Limites do trajeto
Limites do trajeto
1
Tarefa
Kotlin SELF, nível 10, lição 1
Bloqueado
Divisão do saque
Divisão do saque
1
Tarefa
Kotlin SELF, nível 10, lição 1
Bloqueado
Passaporte do retângulo
Passaporte do retângulo
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION