Introduzione a Javatuples

1. Panoramica

Una tupla è una raccolta di diversi elementi che possono o non possono essere correlati tra loro. In altre parole, le tuple possono essere considerate oggetti anonimi.

Ad esempio, ["RAM", 16, "Astra"] è una tupla contenente tre elementi.

In questo articolo daremo una rapida occhiata a una libreria molto semplice che ci permette di lavorare con le strutture dati basate su tuple, chiamate javatuples .

2. Classi Javatuples incorporate

Questa libreria ci fornisce dieci classi diverse che sarebbero sufficienti per la maggior parte dei nostri requisiti relativi alle tuple:

  • Unità
  • Paio
  • Tripletta
  • Quartetto
  • Quintetto
  • Sestetto
  • Septet
  • Ottetto
  • Ennead
  • Decennio

Oltre alle classi precedenti, ci sono due classi aggiuntive, KeyValue e LabelValue , che forniscono funzionalità simili a Pair , ma differiscono nella semantica.

Come per il sito ufficiale, tutte le classi in javatuples sono typesafe e immutabili . Ciascuna delle classi tupla implementa l' interfaccia Iterable , Serializable e Comparable .

3. Aggiunta di dipendenza Maven

Aggiungiamo la dipendenza Maven al nostro pom.xml :

 org.javatuples javatuples 1.2 

Controlla il repository Central Maven per la versione più recente.

4. Creazione di tuple

Creare una tupla è davvero semplice. Possiamo usare i costruttori corrispondenti:

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

C'è anche un modo un po 'meno prolisso e semanticamente elegante di creare una tupla:

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

Possiamo anche creare tuple da un Iterable :

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

Si noti che il numero di elementi nella raccolta deve corrispondere al tipo di tupla che si desidera creare . Ad esempio, non possiamo creare un Quintetto utilizzando la raccolta di cui sopra poiché richiede esattamente cinque elementi. Lo stesso vale per qualsiasi altra classe di tupla con un ordine superiore a Quintet .

Tuttavia, possiamo creare una tupla di ordine inferiore come Pair o Triplet usando la raccolta sopra, specificando un indice iniziale nel metodo fromIterable () :

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

Il codice sopra risulterà nella creazione di una coppia contenente " anne " e " alex ".

Le tuple possono essere comodamente create anche da qualsiasi array:

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

5. Ottenere valori dalle tuple

Ogni classe in javatuples ha un metodo getValueX () per ottenere i valori dalle tuple, dove X specifica l'ordine dell'elemento all'interno della tupla. Come gli indici negli array, il valore di X inizia da zero.

Creiamo un nuovo Quartetto e recuperiamo alcuni valori:

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

Come possiamo vedere, la posizione di " giovanni " è zero, " 72,5 " è uno e così via.

Notare che i metodi getValueX () sono indipendenti dai tipi. Ciò significa che non è richiesto alcun casting.

Un'alternativa a questo è il metodo getValue (int pos) . Richiede una posizione in base zero dell'elemento da recuperare. Questo metodo non è indipendente dai tipi e richiede il cast esplicito :

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

Si noti che le classi KeyValue e LabelValue hanno i metodi corrispondenti getKey () / getValue () e getLabel () / getValue () .

6. Impostazione dei valori su tuple

Simile a getValueX () , tutte le classi in javatuples hanno metodi setAtX () . Di nuovo, X è posizioni in base zero per l'elemento che vogliamo impostare:

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

La cosa importante qui è che il tipo di ritorno del metodo setAtX () è il tipo di tupla stesso. Questo perché le javatuple sono immutabili . L'impostazione di un nuovo valore lascerà intatta l'istanza originale.

7. Aggiunta e rimozione di elementi dalle tuple

Possiamo comodamente aggiungere nuovi elementi alle tuple. Tuttavia, ciò comporterà la creazione di una nuova tupla di un ordine superiore:

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

È chiaro dall'esempio precedente che l'aggiunta di un elemento a una coppia creerà una nuova terzina . Allo stesso modo, l'aggiunta di un elemento a una terzina creerà un nuovo quartetto .

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

In questo articolo, abbiamo esplorato la libreria javatuples e osservato la sua semplicità. Fornisce una semantica elegante ed è davvero facile da usare.

Assicurati di controllare il codice sorgente completo per questo articolo su GitHub. Il codice sorgente completo contiene un po 'più di esempi rispetto a quelli trattati qui. Dopo aver letto questo articolo, gli esempi aggiuntivi dovrebbero essere abbastanza facili da capire.