Introducere în Javatuples

1. Prezentare generală

Un tuplu este o colecție de mai multe elemente care pot sau nu să fie legate între ele. Cu alte cuvinte, tuplurile pot fi considerate obiecte anonime.

De exemplu, [„RAM”, 16, „Astra”] este un tuplu care conține trei elemente.

În acest articol, vom arunca o privire rapidă la o bibliotecă cu adevărat simplă, care ne permite să lucrăm cu structurile de date bazate pe tupluri, numite javatuples .

2. Clasele Javatuples încorporate

Această bibliotecă ne oferă zece clase diferite care ar fi suficiente pentru majoritatea cerințelor noastre legate de tupluri:

  • Unitate
  • Pereche
  • Triplet
  • Cvartet
  • Cvintet
  • Sextet
  • Septet
  • Octet
  • Enadead
  • Deceniu

În plus față de clasele de mai sus, există două clase suplimentare, KeyValue și LabelValue , care oferă funcționalități similare cu Pair , dar diferă din punct de vedere semantic.

Conform site-ului oficial, toate clasele în javatuples sunt sigure și imuabile . Fiecare clasă de tupluri implementează interfața Iterabilă , Serializabilă și Comparabilă .

3. Adăugarea dependenței Maven

Să adăugăm dependența Maven la pom.xml :

 org.javatuples javatuples 1.2 

Vă rugăm să verificați depozitul Central Maven pentru cea mai recentă versiune.

4. Crearea tuplurilor

Crearea unui tuplu este foarte simplă. Putem folosi constructorii corespunzători:

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

Există, de asemenea, un mod puțin mai detaliat și elegant din punct de vedere semantic de a crea un tuplu:

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

De asemenea, putem crea tupluri dintr-un Iterable :

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

Vă rugăm să rețineți că numărul de articole din colecție trebuie să se potrivească cu tipul de tuplu pe care dorim să îl creăm . De exemplu, nu putem crea un cvintet folosind colecția de mai sus, deoarece necesită exact cinci elemente. Același lucru este valabil pentru orice altă clasă de tupluri care are o ordine mai mare decât Quintet .

Cu toate acestea, putem crea un tuplu de ordin mai mic, cum ar fi Pair sau un Triplet, folosind colecția de mai sus, specificând un index de pornire în metoda fromIterable () :

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

Codul de mai sus va avea ca rezultat crearea unei perechi care conține „ anne ” și „ alex “.

Tuplurile pot fi create în mod convenabil și din orice matrice:

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

5. Obținerea de valori de la Tuples

Fiecare clasă din javatuples are o metodă getValueX () pentru obținerea valorilor din tupluri, unde X specifică ordinea elementului din interiorul tuplului. La fel ca indexurile din tablouri, valoarea lui X începe de la zero.

Să creăm un nou cvartet și să aducem câteva 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);

După cum putem vedea, poziția lui „ john ” este zero, „ 72.5 ” este una și așa mai departe.

Rețineți că metodele getValueX () sunt sigure pentru tip. Asta înseamnă că nu este necesară turnarea.

O alternativă la aceasta este metoda getValue (int pos) . Este nevoie de o poziție zero a elementului de preluat. Această metodă nu este sigură pentru tip și necesită distribuire explicită :

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

Rețineți că clasele KeyValue și LabelValue au metodele lor corespunzătoare getKey () / getValue () și getLabel () / getValue () .

6. Setarea valorilor la Tuples

Similar cu getValueX () , toate clasele din javatuples au setAtX () metode. Din nou, X reprezintă poziții bazate pe zero pentru elementul pe care dorim să-l setăm:

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

Important este că tipul returnat al metodei setAtX () este tipul de tuplu în sine. Acest lucru se datorează faptului că javatuples sunt imuabile . Setarea oricărei valori noi va lăsa instanța originală intactă.

7. Adăugarea și eliminarea elementelor din tuples

Putem adăuga în mod convenabil elemente noi la tupluri. Cu toate acestea, acest lucru va duce la crearea unui nou tupl de o ordine mai mare:

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

Este clar din exemplul de mai sus că adăugarea unui element la o pereche va crea un nou triplet . În mod similar, adăugarea unui element la un triplet va crea un nou cvartet .

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

În acest articol, am explorat biblioteca javatuples și am observat simplitatea acesteia. Oferă o semantică elegantă și este foarte ușor de utilizat.

Asigurați-vă că verificați codul sursă complet pentru acest articol pe GitHub. Codul sursă complet conține puțin mai multe exemple decât cele acoperite aici. După citirea acestui articol, exemplele suplimentare ar trebui să fie suficient de ușor de înțeles.