Einführung in Javatuples

1. Übersicht

Ein Tupel ist eine Sammlung mehrerer Elemente, die miteinander in Beziehung stehen können oder nicht. Mit anderen Worten, Tupel können als anonyme Objekte betrachtet werden.

Zum Beispiel ist ["RAM", 16, "Astra"] ein Tupel, das drei Elemente enthält.

In diesem Artikel werfen wir einen kurzen Blick auf eine wirklich einfache Bibliothek, mit der wir mit den tupelbasierten Datenstrukturen namens javatuples arbeiten können .

2. Eingebaute Javatuples- Klassen

Diese Bibliothek bietet uns zehn verschiedene Klassen, die die meisten unserer Anforderungen in Bezug auf Tupel erfüllen würden:

  • Einheit
  • Paar
  • Triplett
  • Quartett
  • Quintett
  • Sextett
  • Septett
  • Oktett
  • Ennead
  • Dekade

Zusätzlich zu den oben genannten Klassen gibt es zwei zusätzliche Klassen, KeyValue und LabelValue , die Funktionalitäten ähnlich zu bieten Pair , unterscheiden sich aber in der Semantik.

Laut der offiziellen Website sind alle Klassen in Javatuples typsicher und unveränderlich . Jede der Tupel - Klasse implementiert die Iterable , Serializable und vergleichbare Schnittstelle.

3. Hinzufügen einer Maven-Abhängigkeit

Fügen wir die Maven-Abhängigkeit zu unserer pom.xml hinzu :

 org.javatuples javatuples 1.2 

Bitte überprüfen Sie das Central Maven-Repository auf die neueste Version.

4. Tupel erstellen

Das Erstellen eines Tupels ist wirklich einfach. Wir können die entsprechenden Konstruktoren verwenden:

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

Es gibt auch eine etwas weniger ausführliche und semantisch elegante Möglichkeit, ein Tupel zu erstellen:

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

Wir können auch Tupel aus einem Iterable erstellen :

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

Bitte beachten Sie, dass die Anzahl der Elemente in der Sammlung dem Typ des Tupels entsprechen sollte, das wir erstellen möchten . Beispielsweise können wir mit der obigen Sammlung kein Quintett erstellen, da genau fünf Elemente erforderlich sind. Gleiches gilt für jede andere Tupelklasse mit einer höheren Ordnung als Quintett .

Mit der obigen Auflistung können wir jedoch ein Tupel niedrigerer Ordnung wie Pair oder Triplet erstellen , indem wir in der fromIterable () -Methode einen Startindex angeben :

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

Der obige Code führt dazu, dass ein Paar erstellt wird, das " anne " und " alex " enthält.

Tupel können auch bequem aus jedem Array erstellt werden:

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

5. Werte aus Tupeln abrufen

Jede Klasse in Javatuples verfügt über eine getValueX () -Methode zum Abrufen der Werte von Tupeln, wobei X die Reihenfolge des Elements innerhalb des Tupels angibt. Wie die Indizes in Arrays beginnt der Wert von X bei Null.

Lassen Sie uns ein neues Quartett erstellen und einige Werte abrufen:

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

Wie wir sehen können, ist die Position von „ John “ Null, „ 72,5 “ ist Eins und so weiter.

Beachten Sie, dass die Methoden getValueX () typsicher sind. Das heißt, es ist kein Gießen erforderlich.

Eine Alternative dazu ist die Methode getValue (int pos) . Es nimmt eine auf Null basierende Position des abzurufenden Elements ein. Diese Methode ist nicht typsicher und erfordert explizites 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);

Bitte beachten Sie, dass die Klassen KeyValue und LabelValue haben ihre entsprechenden Methoden getKey () / getValue () und getLabel () / getValue () .

6. Werte auf Tupel setzen

Ähnlich wie bei getValueX () verfügen alle Klassen in Javatuples über setAtX () -Methoden. Wiederum ist X eine auf Null basierende Position für das Element, das wir setzen möchten:

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

Wichtig hierbei ist, dass der Rückgabetyp der setAtX () -Methode der Tupeltyp selbst ist. Dies liegt daran, dass die Javatuples unveränderlich sind . Wenn Sie einen neuen Wert festlegen, bleibt die ursprüngliche Instanz erhalten.

7. Hinzufügen und Entfernen von Elementen zu Tupeln

Wir können den Tupeln bequem neue Elemente hinzufügen. Dies führt jedoch dazu, dass ein neues Tupel mit einer höheren Ordnung erstellt wird:

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

Aus dem obigen Beispiel geht hervor, dass durch Hinzufügen eines Elements zu einem Paar ein neues Triplet erstellt wird . In ähnlicher Weise wird durch Hinzufügen eines Elements zu einem Triplett ein neues Quartett erstellt .

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 diesem Artikel haben wir die Javatuples-Bibliothek untersucht und festgestellt, dass sie einfach ist. Es bietet eine elegante Semantik und ist sehr einfach zu bedienen.

Stellen Sie sicher, dass Sie den vollständigen Quellcode für diesen Artikel auf GitHub lesen. Der vollständige Quellcode enthält etwas mehr Beispiele als die hier behandelten. Nach dem Lesen dieses Artikels sollten die zusätzlichen Beispiele leicht verständlich sein.