Introdução aos Javatuples
1. Visão geral
Uma tupla é uma coleção de vários elementos que podem ou não estar relacionados entre si. Em outras palavras, as tuplas podem ser consideradas objetos anônimos.
Por exemplo, ["RAM", 16, "Astra"] é uma tupla contendo três elementos.
Neste artigo, daremos uma olhada rápida em uma biblioteca realmente simples que nos permite trabalhar com estruturas de dados baseadas em tupla, chamadasjavatuples.
2. ClassesJavatuples integradas
Essa biblioteca fornece dez classes diferentes que seriam suficientes para a maioria dos requisitos relacionados às tuplas:
Além das classes acima, existem duas classes adicionais,KeyValue<A,B>eLabelValue<A,B>, que fornecem funcionalidades semelhantes aPair<A,B>, mas diferem na semântica.
De acordo comofficial site,all the classes injavatuples are typesafe and immutable. Cada uma das classes de tupla implementa a interfaceIterable,Serializable eComparable.
3. Adicionando Dependência Maven
Vamos adicionar a dependência Maven ao nossopom.xml:
org.javatuples
javatuples
1.2
Verifique o repositório central Maven paralatest version.
4. Criação de tuplas
Criar uma tupla é realmente simples. Podemos usar os construtores correspondentes:
Pair pair = new Pair("A pair", 55); Há também uma maneira um pouco menos detalhada e semanticamente elegante de criar uma tupla:
Triplet triplet = Triplet.with("hello", 23, 1.2); Também podemos criar tuplas de umIterable:
List listOfNames = Arrays.asList("john", "doe", "anne", "alex");
Quartet quartet
= Quartet.fromCollection(collectionOfNames); Observe quethe number of items in the collection should match the type of the tuple that we want to create. Por exemplo, não podemos criar umQuintet usando a coleção acima, pois ela requer exatamente cinco elementos. O mesmo é verdadeiro para qualquer outra classe de tupla com uma ordem superior aQuintet.
No entanto, podemos criar uma tupla de ordem inferior comoPair ou aTriplet usando a coleção acima, especificando um índice inicial no métodofromIterable():
Pair pairFromList = Pair.fromIterable(listOfNames, 2); O código acima resultará na criação de umPair contendo “anne” e “alex“.
Também é possível criar tuplas a partir de qualquer matriz:
String[] names = new String[] {"john", "doe", "anne"};
Triplet triplet2 = Triplet.fromArray(names); 5. Getting Values from Tuples
Cada classe emjavatuples tem um métodogetValueX() para obter os valores das tuplas, ondeX especifica a ordem do elemento dentro da tupla. Como os índices em matrizes, o valor deX começa do zero.
Vamos criar um novo Quarteto e buscar alguns valores:
Quartet quartet
= Quartet.with("john", 72.5, 32, "1051 SW");
String name = quartet.getValue0();
Integer age = quartet.getValue2();
assertThat(name).isEqualTo("john");
assertThat(age).isEqualTo(32); Como podemos ver, a posição de “john” é zero, “72.5” é um e assim por diante.
Observe que os métodosgetValueX() são seguros para o tipo. Isso significa que nenhuma conversão é necessária.
Uma alternativa para isso é o métodogetValue(int pos). É necessária uma posição baseada em zero do elemento a ser buscado. This method is not type-safe and requires explicit casting:
Quartet quartet
= Quartet.with("john", 72.5, 32, "1051 SW");
String name = (String) quartet.getValue(0);
Integer age = (Integer) quartet.getValue(2);
assertThat(name).isEqualTo("john");
assertThat(age).isEqualTo(32); Observe que as classesKeyValueeLabelValue têm seus métodos correspondentesgetKey()/getValue()egetLabel()/getValue().
6. Definindo valores para tuplas
Semelhante agetValueX(), todas as classes em javatuples têm métodossetAtX(). Novamente,X são posições baseadas em zero para o elemento que queremos definir:
Pair john = Pair.with("john", 32);
Pair alex = john.setAt0("alex");
assertThat(john.toString()).isNotEqualTo(alex.toString()); O importante aqui é que o tipo de retorno do métodosetAtX() é o próprio tipo de tupla. Isso ocorre porquethe javatuples are immutable. Definir qualquer novo valor deixará a instância original intacta.
7. Adicionando e removendo elementos de tuplas
Podemos adicionar convenientemente novos elementos às tuplas. No entanto, isso resultará na criação de uma nova tupla de um pedido superior:
Pair pair1 = Pair.with("john", 32);
Triplet triplet1 = pair1.add("1051 SW");
assertThat(triplet1.contains("john"));
assertThat(triplet1.contains(32));
assertThat(triplet1.contains("1051 SW")); É claro a partir do exemplo acima que adicionar um elemento aPair criará um novoTriplet. Da mesma forma, adicionar um elemento aTriplet criará um novoQuartet.
O exemplo acima também demonstra o uso do métodocontains() fornecido por todas as classes emjavatuples. Este é um método realmente útil para verificar se a tupla contém um determinado valor.
Também é possível adicionar uma tupla a outra usando o métodoadd():
Pair pair1 = Pair.with("john", 32);
Pair pair2 = Pair.with("alex", 45);
Quartet quartet2 = pair1.add(pair2);
assertThat(quartet2.containsAll(pair1));
assertThat(quartet2.containsAll(pair2)); Observe o uso do métodocontainsAll(). Ele retornarátrue se todos os elementos depair1 estiverem presentes emquartet2.
Por padrão, o métodoadd() adiciona o elemento como o último elemento da tupla. No entanto, é possível adicionar o elemento em uma determinada posição usando o métodoaddAtX(), ondeX é a posição baseada em zero onde queremos adicionar o elemento:
Pair pair1 = Pair.with("john", 32);
Triplet triplet2 = pair1.addAt1("1051 SW");
assertThat(triplet2.indexOf("john")).isEqualTo(0);
assertThat(triplet2.indexOf("1051 SW")).isEqualTo(1);
assertThat(triplet2.indexOf(32)).isEqualTo(2); Este exemplo adicionaString na posição 1, que é então verificado pelo métodoindexOf(). Observe a diferença na ordem dos tipos dePair<String, Integer>eTriplet<String, String, Integer> após a chamada do métodoaddAt1().
Também podemos adicionar vários elementos usando qualquer um dos métodosadd() ouaddAtX():
Pair pair1 = Pair.with("john", 32);
Quartet quartet1 = pair1.add("alex", 45);
assertThat(quartet1.containsAll("alex", "john", 32, 45)); Para remover um elemento da tupla, podemos usar o métodoremoveFromX(). Novamente,X especifica a posição baseada em zero do elemento a ser removido:
Pair pair1 = Pair.with("john", 32);
Unit unit = pair1.removeFrom0();
assertThat(unit.contains(32)); 8. Convertendo tuplas emList/Array
Já vimos como converterList em tupla. Vejamos agora como converter uma tupla emList:
Quartet quartet
= Quartet.with("john", 72.5, 32, "1051 SW");
List É bem simples. A única coisa a notar aqui é que sempre obteremos umList<Object>,, mesmo se a tupla contiver o mesmo tipo de elementos.
Finalmente, vamos converter a tupla em uma matriz:
Quartet quartet
= Quartet.with("john", 72.5, 32, "1051 SW");
Object[] array = quartet.toArray();
assertThat(array.length).isEqualTo(4); Claro, o métodotoArray() sempre retorna umObject[].
9. Conclusão
Neste artigo, exploramos a biblioteca de javatuples e observamos sua simplicidade. Ele fornece semântica elegante e é realmente fácil de usar.
Certifique-se de verificar o código-fonte completo deste artigoover on GitHub. O código fonte completo contém um pouco mais de exemplos do que os abordados aqui. Depois de ler este artigo, os exemplos adicionais devem ser fáceis de entender.