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 n-uplets 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 très simple qui nous permet de travailler avec les structures de données basées sur des tuple, nomméesjavatuples.
2. ClassesJavatuples intégrées
Cette bibliothèque nous fournit dix classes différentes qui suffiraient à satisfaire la plupart de nos exigences relatives aux n-uplets:
En plus des classes ci-dessus, il existe deux classes supplémentaires,KeyValue<A,B> etLabelValue<A,B>, qui fournissent des fonctionnalités similaires àPair<A,B>, mais diffèrent dans la sémantique.
Selon lesofficial site,all the classes injavatuples are typesafe and immutable. Chacune des classes de tuple implémente les interfacesIterable,Serializable etComparable.
3. Ajouter une dépendance Maven
Ajoutons la dépendance Maven à nospom.xml:
org.javatuples
javatuples
1.2
Veuillez vérifier le dépôt central de Maven pour leslatest 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'unIterable:
List listOfNames = Arrays.asList("john", "doe", "anne", "alex");
Quartet quartet
= Quartet.fromCollection(collectionOfNames); Veuillez noter quethe number of items in the collection should match the type of the tuple that we want to create. Par exemple, nous ne pouvons pas créer unQuintet 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 commePair ou unTriplet en utilisant la collection ci-dessus, en spécifiant un index de départ dans la méthodefromIterable():
Pair pairFromList = Pair.fromIterable(listOfNames, 2); Le code ci-dessus entraînera la création d'unPair contenant «anne» et «alex».
Les tuples peuvent être facilement créés à partir de n’importe quel tableau:
String[] names = new String[] {"john", "doe", "anne"};
Triplet triplet2 = Triplet.fromArray(names); 5. Getting Values from Tuples
Chaque classe dejavatuples a une méthodegetValueX() 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 deX part de 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éthodesgetValueX() sont de type sécurisé. Cela signifie qu'aucun casting n'est requis.
Une alternative à cela est la méthodegetValue(int pos). Il faut une position zéro de l'élément à récupérer. 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); Veuillez noter que les classesKeyValue etLabelValue ont leurs méthodes correspondantesgetKey()/getValue() etgetLabel()/getValue().
6. Définition des valeurs des tuples
Semblable àgetValueX(), toutes les classes dans javatuples ont des méthodessetAtX(). Encore une fois,X correspond à des 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éthodesetAtX() est le type tuple lui-même. C'est parce quethe javatuples are immutable. La définition d’une nouvelle valeur laissera l’instance d’origine intacte.
7. Ajouter et supprimer des éléments des tuples
Nous pouvons facilement ajouter de nouveaux éléments aux n-uplets. 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 à unPair créera un nouveauTriplet. De même, l'ajout d'un élément à unTriplet créera un nouveauQuartet.
L'exemple ci-dessus démontre également l'utilisation de la méthodecontains() fournie par toutes les classes dejavatuples. C'est une méthode très pratique pour vérifier si le tuple contient une valeur donnée.
Il est également possible d'ajouter un tuple à un autre en utilisant la méthodeadd():
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)); Notez l'utilisation de la méthodecontainsAll(). Il renverratrue si tous les éléments depair1 sont présents dansquartet2.
Par défaut, la méthodeadd() ajoute l'élément comme dernier élément du tuple. Cependant, il est possible d'ajouter l'élément à une position donnée en utilisant la méthodeaddAtX(), oùX est la position de base zéro à laquelle nous voulons ajouter l'élément:
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); Cet exemple ajoute lesString à la position 1, qui sont ensuite vérifiés par la méthodeindexOf(). Veuillez noter la différence dans l'ordre des types pour lesPair<String, Integer> et lesTriplet<String, String, Integer> après l'appel à la méthodeaddAt1().
Nous pouvons également ajouter plusieurs éléments en utilisant l'une des méthodesadd() ouaddAtX():
Pair pair1 = Pair.with("john", 32);
Quartet quartet1 = pair1.add("alex", 45);
assertThat(quartet1.containsAll("alex", "john", 32, 45)); Afin de supprimer un élément du tuple, nous pouvons utiliser la méthoderemoveFromX(). Encore une fois,X spécifie la position de base zéro de l'élément à supprimer:
Pair pair1 = Pair.with("john", 32);
Unit unit = pair1.removeFrom0();
assertThat(unit.contains(32)); 8. Conversion de tuples enList/Array
Nous avons déjà vu comment convertir unList en tuple. Voyons maintenant comment convertir un tuple enList:
Quartet quartet
= Quartet.with("john", 72.5, 32, "1051 SW");
List C'est assez simple. La seule chose à noter ici est que nous obtiendrons toujours unList<Object>, même si le tuple contient le même type d'éléments.
Enfin, convertissons le tuple en tableau:
Quartet quartet
= Quartet.with("john", 72.5, 32, "1051 SW");
Object[] array = quartet.toArray();
assertThat(array.length).isEqualTo(4); Assez clair, la méthodetoArray() renvoie toujours unObject[].
9. Conclusion
Dans cet article, nous avons exploré la bibliothèque javatuples et constaté sa simplicité. Il fournit une sémantique élégante et est vraiment facile à utiliser.
Assurez-vous de vérifier le code source complet de cet articleover on GitHub. Le code source complet contient un peu plus d'exemples que ceux présentés ici. Après avoir lu cet article, les exemples supplémentaires doivent être assez faciles à comprendre.