Introduktion till Javatuples

1. Översikt

En tuple är en samling av flera element som kan eller inte är relaterade till varandra. Med andra ord kan tuplar betraktas som anonyma objekt.

Till exempel är ["RAM", 16, "Astra"] en tuple som innehåller tre element.

I den här artikeln tittar vi snabbt på ett riktigt enkelt bibliotek som gör att vi kan arbeta med de tupelbaserade datastrukturerna, namngavna javatuples .

2. Inbyggda Javatuples- klasser

Det här biblioteket ger oss tio olika klasser som räcker för de flesta av våra krav på tuplar:

  • Enhet
  • Par
  • Triplett
  • Kvartett
  • Kvintett
  • Sextett
  • Septet
  • Oktett
  • Ennead
  • Årtionde

Förutom klasserna ovan finns det två ytterligare klasser, KeyValue och LabelValue , som ger funktioner som liknar Pair , men skiljer sig åt i semantik.

Enligt den officiella webbplatsen är alla klasser i javatuples typsäkra och oföränderliga . Var och en av tuple-klassen implementerar gränssnittet Iterabelt , Serialiserbart och Jämförbart .

3. Lägga till Maven-beroende

Låt oss lägga till Maven-beroendet i vår pom.xml :

 org.javatuples javatuples 1.2 

Kontrollera Central Maven-arkivet för den senaste versionen.

4. Skapa tuples

Att skapa en tuple är verkligen enkelt. Vi kan använda motsvarande konstruktörer:

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

Det finns också ett lite mindre detaljerat och semantiskt elegant sätt att skapa en tupel:

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

Vi kan också skapa tuplar från en Iterabel :

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

Observera att antalet objekt i samlingen ska matcha den typ av tuple som vi vill skapa . Vi kan till exempel inte skapa en kvintett med ovanstående samling eftersom den kräver exakt fem element. Samma sak gäller för alla andra tuplekurser som har en högre ordning än Quintet .

Vi kan dock skapa en lägre ordning tuple som par eller en triplett med ovanstående samling genom att ange ett startindex i metoden fromIterable () :

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

Ovanstående kod kommer att resultera i att skapa ett par som innehåller " anne " och " alex ".

Tuples kan också enkelt skapas från vilken grupp som helst:

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

5. Få värden från tuples

Varje klass i javatuples har en getValueX () -metod för att få värdena från tuples, där X anger ordningen på elementet inuti tupeln. Liksom indexen i matriser börjar X- värdet från noll.

Låt oss skapa en ny kvartett och hämta några värden:

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

Som vi kan se är positionen för " john " noll, " 72,5 " är en, och så vidare.

Observera att getValueX () -metoderna är typsäkra. Det betyder att ingen gjutning krävs.

Ett alternativ till detta är getValue (int pos) -metoden. Det tar en nollbaserad position för det element som ska hämtas. Den här metoden är inte typsäker och kräver uttrycklig gjutning :

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

Observera att klasserna KeyValue och LabelValue har motsvarande metoder getKey () / getValue () och getLabel () / getValue () .

6. Ställa in värden på tuples

På samma sätt som getValueX () har alla klasser i javatuples setAtX () -metoder. Återigen är X nollbaserade positioner för det element som vi vill ställa in:

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

Det viktiga här är att returtypen setAtX () -metod är själva tupletypen. Detta beror på att javatuplesna är oföränderliga . Om du ställer in ett nytt värde kommer den ursprungliga instansen att vara intakt.

7. Lägga till och ta bort element från tuples

Vi kan enkelt lägga till nya element i tuplarna. Detta kommer dock att resultera i att en ny tuple av en ordning högre skapas:

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

Det framgår av exemplet ovan att lägga till ett element i ett par kommer att skapa en ny triplett . På samma sätt skapar en ny kvartett genom att lägga till ett element i en triplett .

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

I den här artikeln har vi utforskat javatuples-biblioteket och observerat dess enkelhet. Det ger elegant semantik och är väldigt lätt att använda.

Se till att du kolla in hela källkoden för den här artikeln på GitHub. Den kompletta källkoden innehåller lite fler exempel än de som beskrivs här. Efter att ha läst den här artikeln bör de ytterligare exemplen vara tillräckligt enkla att förstå.