Introdução
Tuplas são uma estrutura de dados que pode armazenar dados de diferentes tipos em uma sequência ordenada. Java não fornece uma estrutura de dados de tupla, mas podemos usar bibliotecas como Java tuples para trabalhar com elas.
Introdução às Tuplas em Java
Criar uma Tupla em Java
Criar uma tupla em Java é fácil. Você pode criar uma nova tupla especificando os tipos de dados dos elementos e seus valores. Por exemplo:
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Triplet<String, Double, Integer> tuple = Triplet.with("Hello", 3.14, 42);
System.out.println(tuple);
}
}Neste exemplo, criamos uma nova tupla Triplet que contém um elemento String, Double e Integer. Em seguida, usamos o método with() para definir os valores dos elementos e imprimir a tupla no console.
Acessar Valores de Tuplas em Java
Você pode acessar os valores de uma tupla em Java usando os métodos getValue() ou getValueX(), onde X é o índice do elemento que você deseja acessar. O método getValue() não é type-safe (seguro para tipos), então você precisará converter o valor para o tipo de dado correto. O método getValueX(), por outro lado, é type-safe e não requer conversão.
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Triplet<String, Double, Integer> tuple = Triplet.with("Hello", 3.14, 42);
// Access values using getValue()
Integer value1 = (Integer)tuple.getValue(2);
Double value2 = (Double)tuple.getValue(1);
String value3 = (String)tuple.getValue(0);
// Access values using getValueX()
Integer value4 = tuple.getValue2();
Double value5 = tuple.getValue1();
String value6 = tuple.getValue0();
System.out.println(value1 + " " + value2 + " " + value3);
System.out.println(value4 + " " + value5 + " " + value6);
}
}Neste exemplo, usamos tanto getValue() quanto getValueX() para acessar os valores da tupla Triplet. Em seguida, imprimimos os valores no console.
Modificar Valores de Tuplas em Java
Tuplas são imutáveis, então você não pode modificá-las diretamente. Em vez disso, você pode usar o método setAtX() para criar uma nova tupla com o valor modificado. O método setAtX() retorna uma nova tupla, então certifique-se de atribuí-la a uma variável.
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Triplet<String, Double, Integer> tuple = Triplet.with("Hello", 3.14, 42);
Triplet<String, Double, Integer> newTuple = tuple.setAt1(2.71);
System.out.println(tuple);
System.out.println(newTuple);
}
}Neste exemplo, usamos o método setAt1() para modificar o segundo elemento da tupla Triplet. Em seguida, imprimimos ambas as tuplas, a original e a modificada, no console.
Adicionar Elementos a uma Tupla em Java
Você pode adicionar elementos a uma tupla em Java criando uma nova tupla de tamanho maior que inclua os novos elementos. Você pode usar o método add() para adicionar um elemento ao final da tupla, ou o método addAtX() para inserir um elemento em um índice específico.
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Triplet<String, Double, Integer> tuple = Triplet.with("Hello", 3.14, 42);
Quartet<String, Double, Integer, Boolean> newTuple1 = tuple.add(true);
Quartet<String, Double, Boolean, Integer> newTuple2 = tuple.addAt2(true);
System.out.println(tuple);
System.out.println(newTuple1);
System.out.println(newTuple2);
}
}Neste exemplo, usamos tanto add() quanto addAtX() para adicionar um novo elemento Boolean à tupla Triplet. Em seguida, imprimimos todas as três tuplas no console.
Remover Elementos de uma Tupla
Você pode remover elementos de uma tupla em Java usando o método removeFromX(), onde X é o índice do elemento que você deseja remover. O método removeFromX() retorna uma nova tupla, então certifique-se de atribuí-la a uma variável.
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Quartet<String, Double, Integer, Boolean> tuple = Quartet.with("Hello", 3.14, 42, true);
Triplet<Double, Integer, Boolean> newTuple1 = tuple.removeFrom0();
Triplet<String, Double, Integer> newTuple2 = tuple.removeFrom3();
System.out.println(tuple);
System.out.println(newTuple1);
System.out.println(newTuple2);
}
}Neste exemplo, usamos removeFrom0() e removeFrom3() para remover o primeiro e o último elementos da tupla Quartet. Em seguida, imprimimos todas as três tuplas no console.
Looping/Iterando em uma Tupla em Java
Você pode iterar sobre uma tupla em Java usando o loop for-each. Como as tuplas implementam a interface Iterable, você pode usá-las em um loop como qualquer outra coleção.
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Triplet<String, Double, Integer> tuple = Triplet.with("Hello", 3.14, 42);
for (Object element : tuple) {
System.out.println(element);
}
}
}Neste exemplo, iteramos sobre a tupla Triplet usando um loop for-each e imprimimos cada elemento no console.
Verificar a Presença de um Elemento em uma Tupla em Java
Você pode verificar se uma tupla contém um elemento específico ou uma coleção de elementos usando os métodos contains() e containsAll().
O método contains() retorna true se a tupla contém o elemento fornecido, e containsAll() retorna true se a tupla contém todos os elementos em uma coleção.
import org.javatuples.*;
import java.util.Arrays;
import java.util.List;
public class TupleDemo {
public static void main(String[] args) {
Triplet<String, Double, Integer> tuple = Triplet.with("Hello", 3.14, 42);
List<Integer> list = Arrays.asList(42, 7);
boolean containsHello = tuple.contains("Hello");
boolean containsWorld = tuple.contains("World");
boolean containsAll = tuple.containsAll(list);
System.out.println(containsHello);
System.out.println(containsWorld);
System.out.println(containsAll);
}
}Neste exemplo, usamos contains() e containsAll() para verificar se a tupla Triplet contém elementos específicos ou uma coleção de elementos. Em seguida, imprimimos os resultados no console.
Obter o Índice de um Elemento em uma Tupla em Java
Você pode obter o índice de um elemento específico em uma tupla usando os métodos indexOf() e lastIndexOf(). indexOf() retorna o índice da primeira ocorrência do elemento, enquanto lastIndexOf() retorna o índice da última ocorrência.
import org.javatuples.*;
public class TupleDemo {
public static void main(String[] args) {
Quartet<String, Double, Integer, Integer> tuple = Quartet.with("a", 1.0, 1, 2);
int firstIndex = tuple.indexOf(1);
int lastIndex = tuple.lastIndexOf(1);
System.out.println(firstIndex);
System.out.println(lastIndex);
}
}Neste exemplo, usamos indexOf() e lastIndexOf() para obter o índice do elemento Integer na tupla Quartet. Em seguida, imprimimos os resultados no console.
Converter Tupla para Array ou Lista em Java
Você pode converter uma tupla para um array ou lista usando os métodos toArray() e toList(), respectivamente.
import org.javatuples.*;
import java.util.Arrays;
import java.util.List;
public class TupleDemo {
public static void main(String[] args) {
Quartet<String, Double, Integer, Boolean> tuple = Quartet.with("Hello", 3.14, 42, true);
Object[] arr = tuple.toArray();
List<Object> list = tuple.toList();
System.out.println(Arrays.toString(arr));
System.out.println(list);
}
}Neste exemplo, usamos toArray() e toList() para converter a tupla Quartet para um array e uma lista, respectivamente. Em seguida, imprimimos ambos no console.
Resumo
Neste laboratório, aprendemos como criar, acessar, modificar e iterar sobre tuplas em Java usando a biblioteca de tuplas Java. Também aprendemos como adicionar e remover elementos, verificar a presença de elementos, obter índices de elementos e converter tuplas em arrays ou listas. Ao praticar esses métodos, você agora deve ser capaz de trabalhar com tuplas de forma eficaz em seus próprios programas Java.
