Introduction à Javatuples

1. Vue d'ensemble

Un tuple est une collection de plusieurs éléments qui peuvent ou non être liés les uns aux autres. En d'autres termes, les tuples peuvent être considérés comme des objets anonymes.

Par exemple, [«RAM», 16, «Astra»] est un tuple contenant trois éléments.

Dans cet article, nous allons jeter un coup d'œil sur une bibliothèque vraiment simple qui nous permet de travailler avec les structures de données basées sur des tuple, nommées javatuples .

2. Classes Javatuples intégrées

Cette bibliothèque nous fournit dix classes différentes qui suffiraient à la plupart de nos exigences liées aux tuples:

  • Unité
  • Paire
  • Triolet
  • Quatuor
  • Quintette
  • Sextuor
  • Septuor
  • Octuor
  • Ennead
  • Décennie

En plus des classes ci-dessus, il existe deux classes supplémentaires, KeyValue et LabelValue , qui fournissent des fonctionnalités similaires à Pair , mais qui diffèrent dans la sémantique.

Selon le site officiel, toutes les classes de javatuples sont sécurisées et immuables . Chacune de la classe tuple implémente l' interface Iterable , Serializable et Comparable .

3. Ajout de la dépendance Maven

Ajoutons la dépendance Maven à notre pom.xml :

 org.javatuples javatuples 1.2 

Veuillez vérifier le référentiel Central Maven pour la dernière version.

4. Création de tuples

Créer un tuple est vraiment simple. Nous pouvons utiliser les constructeurs correspondants:

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

Il existe également une manière un peu moins verbeuse et sémantiquement élégante de créer un tuple:

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

Nous pouvons également créer des tuples à partir d'un Iterable :

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

Veuillez noter que le nombre d'éléments de la collection doit correspondre au type du tuple que nous voulons créer . Par exemple, nous ne pouvons pas créer un Quintet en utilisant la collection ci-dessus car elle nécessite exactement cinq éléments. Il en va de même pour toute autre classe de tuple ayant un ordre supérieur à Quintet .

Cependant, nous pouvons créer un tuple d'ordre inférieur comme Pair ou un Triplet en utilisant la collection ci-dessus, en spécifiant un index de départ dans la méthode fromIterable () :

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

Le code ci-dessus entraînera la création d'une paire contenant « anne » et « alex ».

Les tuples peuvent également être créés à partir de n'importe quel tableau:

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

5. Obtenir des valeurs à partir de tuples

Chaque classe de javatuples a une méthode getValueX () pour obtenir les valeurs des tuples, où X spécifie l'ordre de l'élément à l'intérieur du tuple. Comme les index dans les tableaux, la valeur de X commence à zéro.

Créons un nouveau quatuor et récupérons quelques valeurs:

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

Comme nous pouvons le voir, la position de « john » est zéro, « 72,5 » est un, et ainsi de suite.

Notez que les méthodes getValueX () sont de type sécurisé. Cela signifie qu'aucune coulée n'est requise.

Une alternative à cela est la méthode getValue (int pos) . Il prend une position de base zéro de l'élément à extraire. Cette méthode n'est pas de type sécurisé et nécessite une conversion explicite :

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

Veuillez noter que les classes KeyValue et LabelValue ont leurs méthodes correspondantes getKey () / getValue () et getLabel () / getValue () .

6. Définition des valeurs des tuples

Semblable à getValueX () , toutes les classes de javatuples ont des méthodes setAtX () . Encore une fois, X correspond aux positions de base zéro pour l'élément que nous voulons définir:

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

L'important ici est que le type de retour de la méthode setAtX () est le type de tuple lui-même. C'est parce que les javatuples sont immuables . La définition d'une nouvelle valeur laissera l'instance d'origine intacte.

7. Ajout et suppression d'éléments des tuples

Nous pouvons facilement ajouter de nouveaux éléments aux tuples. Cependant, cela entraînera la création d'un nouveau tuple d'un ordre supérieur:

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

Il est clair d'après l'exemple ci-dessus que l'ajout d'un élément à une paire créera un nouveau triplet . De même, l'ajout d'un élément à un triplet créera un nouveau quatuor .

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

Dans cet article, nous avons exploré la bibliothèque javatuples et observé sa simplicité. Il fournit une sémantique élégante et est vraiment facile à utiliser.

Assurez-vous de consulter le code source complet de cet article sur GitHub. Le code source complet contient un peu plus d'exemples que ceux abordés ici. Après avoir lu cet article, les exemples supplémentaires devraient être assez faciles à comprendre.