Introducción a Javatuples

Programación

1. Información general

Una tupla es una colección de varios elementos que pueden estar o no relacionados entre sí. En otras palabras, las tuplas pueden considerarse objetos anónimos.

Por ejemplo, [“RAM”, 16, “Astra”] es una tupla que contiene tres elementos.

En este artículo, veremos rápidamente una biblioteca realmente simple que nos permite trabajar con estructuras de datos basadas en tuplas, llamadas javatuples .

2. Clases de Javatuples integradas

Esta biblioteca nos proporciona diez clases diferentes que serían suficientes para la mayoría de nuestros requisitos relacionados con tuplas:

  • Unidad
  • Par
  • Trillizo
  • Cuarteto
  • Quinteto
  • Sexteto
  • Septeto
  • Octeto
  • Enéada
  • Década

Además de las clases anteriores, hay dos clases adicionales, KeyValue y LabelValue , que proporcionan funcionalidades similares a Pair , pero difieren en semántica.

Según el sitio oficial, todas las clases en javatuples son seguras e inmutables . Cada una de las clases de tuplas implementa la interfaz Iterable , Serializable y Comparable .

3. Agregar dependencia de Maven

Agreguemos la dependencia de Maven a nuestro pom.xml :

 org.javatuples javatuples 1.2

Consulte el repositorio de Central Maven para obtener la última versión.

4. Creando tuplas

Crear una tupla es realmente sencillo. Podemos utilizar los constructores correspondientes:

Pair pair = new Pair("A pair", 55);

También hay una forma un poco menos detallada y semánticamente elegante de crear una tupla:

Triplet triplet = Triplet.with("hello", 23, 1.2);

También podemos crear tuplas a partir de un Iterable :

List listOfNames = Arrays.asList("john", "doe", "anne", "alex"); Quartet quartet = Quartet.fromCollection(collectionOfNames);

Tenga en cuenta que la cantidad de elementos de la colección debe coincidir con el tipo de tupla que queremos crear . Por ejemplo, no podemos crear un Quinteto usando la colección anterior ya que requiere exactamente cinco elementos. Lo mismo ocurre con cualquier otra clase de tupla que tenga un orden superior a Quintet .

Sin embargo, podemos crear una tupla de orden inferior como Pair o Triplet usando la colección anterior, especificando un índice de inicio en el método fromIterable () :

Pair pairFromList = Pair.fromIterable(listOfNames, 2);

El código anterior dará como resultado la creación de un par que contenga " anne " y " alex ".

Las tuplas también se pueden crear convenientemente a partir de cualquier matriz:

String[] names = new String[] {"john", "doe", "anne"}; Triplet triplet2 = Triplet.fromArray(names);

5. Obtener valores de tuplas

Cada clase en javatuples tiene un método getValueX () para obtener los valores de las tuplas, donde X especifica el orden del elemento dentro de la tupla. Como los índices en matrices, el valor de X comienza desde cero.

Creemos un nuevo Cuarteto y busquemos algunos 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, la posición de " juan " es cero, " 72.5 " es uno, y así sucesivamente.

Tenga en cuenta que los métodos getValueX () son seguros para los tipos. Eso significa que no se requiere casting.

Una alternativa a esto es el método getValue (int pos) . Se necesita una posición de base cero del elemento que se va a buscar. Este método no es seguro para tipos y requiere conversión explícita :

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);

Tenga en cuenta que las clases KeyValue y LabelValue tienen sus métodos correspondientes getKey () / getValue () y getLabel () / getValue () .

6. Establecer valores en tuplas

Similar a getValueX () , todas las clases en javatuples tienen métodos setAtX () . Nuevamente, X son posiciones de base cero para el elemento que queremos establecer:

Pair john = Pair.with("john", 32); Pair alex = john.setAt0("alex"); assertThat(john.toString()).isNotEqualTo(alex.toString());

Lo importante aquí es que el tipo de retorno del método setAtX () es el tipo de tupla en sí. Esto se debe a que los javatuples son inmutables . Establecer cualquier valor nuevo dejará intacta la instancia original.

7. Agregar y eliminar elementos de tuplas

Podemos agregar convenientemente nuevos elementos a las tuplas. Sin embargo, esto dará como resultado la creación de una nueva tupla de un orden 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"));

Se desprende del ejemplo anterior que agregar un elemento a un par creará un nuevo triplete . De manera similar, agregar un elemento a un triplete creará un nuevo cuarteto .

The example above also demonstrates the use of contains() method provided by all the classes in javatuples. This is a really handy method for verifying if the tuple contains a given value.

It is also possible to add one tuple to another using the add() method:

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));

Note the use of containsAll() method. It will return true if all the elements of pair1 are present in quartet2.

By default, the add() method adds the element as a last element of the tuple. However, it is possible to add the element at a given position using addAtX() method, where X is the zero-based position where we want to add the element:

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);

This example adds the String at position 1, which is then verified by the indexOf() method. Please note the difference in order of the types for the Pair and the Triplet after the call to addAt1() method call.

We can also add multiple elements using any of add() or addAtX() methods:

Pair pair1 = Pair.with("john", 32); Quartet quartet1 = pair1.add("alex", 45); assertThat(quartet1.containsAll("alex", "john", 32, 45));

In order to remove an element from the tuple, we can use the removeFromX() method. Again, X specifies the zero-based position of the element to be removed:

Pair pair1 = Pair.with("john", 32); Unit unit = pair1.removeFrom0(); assertThat(unit.contains(32));

8. Converting Tuples to List/Array

We have already seen how to convert a List to a tuple. Let's now see hot to convert a tuple to a List:

Quartet quartet = Quartet.with("john", 72.5, 32, "1051 SW"); List list = quartet.toList(); assertThat(list.size()).isEqualTo(4);

It is fairly simple. The only thing to note here is that we will always get a List, even if the tuple contains the same type of elements.

Finally, let's convert the tuple to an array:

Quartet quartet = Quartet.with("john", 72.5, 32, "1051 SW"); Object[] array = quartet.toArray(); assertThat(array.length).isEqualTo(4);

Clear enough, the toArray() method always returns an Object[].

9. Conclusion

En este artículo, hemos explorado la biblioteca javatuples y hemos observado su simplicidad. Proporciona una semántica elegante y es realmente fácil de usar.

Asegúrese de consultar el código fuente completo de este artículo en GitHub. El código fuente completo contiene un poco más de ejemplos que los que se tratan aquí. Después de leer este artículo, los ejemplos adicionales deberían ser lo suficientemente fáciles de entender.