JavaTuples - Guida rapida

Tupla

La tupla è una sequenza di oggetti che possono o meno essere dello stesso tipo. Considera il seguente esempio:

[12,"TutorialsPoint", java.sql.Connection@li757b]

L'oggetto sopra è una tupla di tre elementi, un intero, una stringa e un oggetto di connessione.

JavaTuple

JavaTuples è una libreria molto semplice che offre dieci diverse classi di tupla sufficienti per gestire la maggior parte dei requisiti relativi alle tuple.

Unità <A> - 1 elemento
Coppia <A, B> - 2 elementi
Tripletta <A, B, C> - 3 elementi
Quartetto <LA, SI, DO, RE> - 4 elementi
Quintetto <La, Si, Do, Re, Mi> - 5 elementi
Sestetto <LA, SI, DO, RE, MI, FA> - 6 elementi
Settetto <LA, SI, DO, RE, MI, FA, SOL> - 7 elementi
Ottetto <LA, SI, DO, RE, MI, FA, SOL, MI> - 8 elementi
Ennead <A, B, C, D, E, F, G, H, I> - 9 elementi
Decennio <LA, SI, DO, RE, MI, FA, SOL, H, I, J> - 10 elementi

Oltre a queste classi di tuple, JavaTuples fornisce anche due classi aggiuntive per motivi di semantica.

KeyValue<A,B>
LabelValue<A,B>

Tutte le classi di tuple sono sicure per i tipi e immutabili e implementano le seguenti interfacce e metodi.

Iterable
Serializable
Comparable<Tuple>
equals()
hashCode()
toString()

Tupla vs elenco / matrice

List o Array possono contenere un numero qualsiasi di elementi, ma ogni elemento deve essere dello stesso tipo mentre le tuple possono contenere solo un numero specifico di elementi, possono avere diversi tipi di elementi ma sono comunque indipendenti dal tipo.

Configurazione dell'ambiente locale

Se sei ancora disposto a configurare il tuo ambiente per il linguaggio di programmazione Java, questa sezione ti guiderà su come scaricare e configurare Java sulla tua macchina. Seguire i passaggi indicati di seguito per configurare l'ambiente.

Java SE è disponibile gratuitamente dal collegamento Scarica Java . Quindi scarichi una versione basata sul tuo sistema operativo.

Segui le istruzioni per scaricare Java ed eseguire il file .exeper installare Java sulla tua macchina. Dopo aver installato Java sulla macchina, è necessario impostare le variabili di ambiente in modo che puntino alle directory di installazione corrette -

Configurazione del percorso per Windows 2000 / XP

Supponiamo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

Fare clic con il pulsante destro del mouse su "Risorse del computer" e selezionare "Proprietà".
Fare clic sul pulsante "Variabili d'ambiente" nella scheda "Avanzate".
Ora, modifica la variabile "Path" in modo che contenga anche il percorso dell'eseguibile Java. Ad esempio, se il percorso è attualmente impostato su "C: \ WINDOWS \ SYSTEM32", modificare il percorso in "C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin".

Impostazione del percorso per Windows 95/98 / M

Supponiamo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

Modifica il file "C: \ autoexec.bat" e aggiungi la seguente riga alla fine: "SET PATH =% PATH%; C: \ Program Files \ java \ jdk \ bin"

Configurazione del percorso per Linux, UNIX, Solaris, FreeBS

La variabile d'ambiente PATH dovrebbe essere impostata in modo che punti a dove sono stati installati i binari Java. Fare riferimento alla documentazione della shell se si hanno problemi a farlo.

Esempio, se usi bash come shell, aggiungi la seguente riga alla fine di '.bashrc: export PATH = / path / to / java: $ PATH'

Popolare Java Editor

Per scrivere i tuoi programmi Java, hai bisogno di un editor di testo. Ci sono molti IDE sofisticati disponibili sul mercato. Ma per ora, puoi considerare uno dei seguenti:

Notepad - Su una macchina Windows puoi usare qualsiasi semplice editor di testo come Blocco note (consigliato per questo tutorial), TextPad.
Netbeans- È un IDE Java open source e gratuito che può essere scaricato da www.netbeans.org/index.html .
Eclipse- È anche un IDE Java sviluppato dalla comunità open source di eclipse e può essere scaricato da www.eclipse.org .

Scarica JavaTuples Archie

Scarica l'ultima versione del file jar JavaTuples da Maven Repository - JavaTuples . In questo tutorial, javatuples-1.2.jar viene scaricato e copiato nella cartella C: \> javatuples.

OS	Nome dell'archivio
finestre	javatuples-1.2.jar
Linux	javatuples-1.2.jar
Mac	javatuples-1.2.jar

Imposta l'ambiente JavaTuples

Impostare il JavaTuplesvariabile di ambiente per puntare alla posizione della directory di base in cui il jar JavaTuples è memorizzato sulla macchina. Supponendo, abbiamo estratto javatuples-1.2.jar nella cartella JavaTuples su vari sistemi operativi come segue.

OS	Produzione
finestre	Imposta la variabile d'ambiente JavaTuples su C: \ JavaTuples
Linux	export JavaTuples = / usr / local / JavaTuples
Mac	export JavaTuples = / Library / JavaTuples

Imposta la variabile CLASSPATH

Impostare il CLASSPATHvariabile di ambiente in modo che punti alla posizione del jar JavaTuples. Supponendo che tu abbia memorizzato javatuples-1.2.jar nella cartella JavaTuples su vari sistemi operativi come segue.

OS	Produzione
finestre	Impostare la variabile d'ambiente CLASSPATH su% CLASSPATH%;% JavaTuples% \ javatuples-1.2.jar;.;
Linux	export CLASSPATH = $ CLASSPATH: $ JavaTuples / javatuples-1.2.jar :.
Mac	export CLASSPATH = $ CLASSPATH: $ JavaTuples / javatuples-1.2.jar :.

Una tupla che utilizza le classi JavaTuple può essere creata utilizzando più opzioni. Di seguito sono riportati gli esempi:

Utilizzo dei metodi with ()

Ogni classe di tupla ha un metodo with () con i parametri corrispondenti. Ad esempio:

Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5));
Triplet<String, Integer, Double> triplet = Triplet.with("Test", Integer.valueOf(5), 
   Double.valueOf(32.1));

Utilizzando Constructor

Ogni classe di tupla ha un costruttore con parametri corrispondenti. Ad esempio:

Pair<String, Integer> pair = new Pair("Test", Integer.valueOf(5));
Triplet<String, Integer, Double> triplet = new Triplet("Test", Integer.valueOf(5), 
   Double.valueOf(32.1));

Utilizzo delle raccolte

Ogni classe tupla ha un metodo fromCollection () con parametri corrispondenti. Ad esempio:

Pair<String, Integer> pair = Pair.fromCollection(listOfTwoElements);

Utilizzando Iterable

Ogni classe di tupla ha un metodo fromIterable () per ottenere elementi in modo generico. Ad esempio:

// Retrieve three values from an iterable starting at index 5
Triplet<Integer,Integer,Integer> triplet = Triplet.fromIterable(listOfInts, 5);

Esempio

Vediamo JavaTuples in azione. Qui vedremo come creare tupels usando vari modi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Pair;

public class TupleTester {
   public static void main(String args[]){
      //Create using with() method
      Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5));   
      //Create using constructor()
      Pair<String, Integer> pair1 = new Pair("Test", Integer.valueOf(5)); 
      List<Integer> listOfInts = new ArrayList<Integer>();
      listOfInts.add(1);
      listOfInts.add(2);
      //Create using fromCollection() method
      Pair<Integer, Integer> pair2 = Pair.fromCollection(listOfInts);	  
      listOfInts.add(3);
      listOfInts.add(4);
      listOfInts.add(5);
      listOfInts.add(6);
      listOfInts.add(8);
      listOfInts.add(9);
      listOfInts.add(10);
      listOfInts.add(11);
      //Create using fromIterable() method
      // Retrieve three values from an iterable starting at index 5
      Pair<Integer,Integer> pair3 = Pair.fromIterable(listOfInts, 5);
      //print all tuples
      System.out.println(pair);
      System.out.println(pair1);
      System.out.println(pair2);
      System.out.println(pair3);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[Test, 5]
[Test, 5]
[1, 2]
[6, 8]

Una tupla ha metodi getValueX () per ottenere valori e getValue () un metodo generico per ottenere valore in base all'indice. Ad esempio, la classe Triplet ha i seguenti metodi.

getValue(index) - restituisce il valore all'indice a partire da 0.
getValue0() - restituisce il valore all'indice 0.
getValue1() - restituisce il valore all'indice 1.
getValue2() - restituisce il valore all'indice 2.

Caratteristica

I metodi getValueX () sono typesafe e non è richiesto alcun cast, ma getValue (index) è generico.
Una tupla ha metodi getValueX () fino al conteggio degli elementi. Ad esempio, Triplet non ha il metodo getValue3 () ma Quartet lo ha.
Le classi semantiche KeyValue e LabelValue hanno getKey () / getValue () e getLabel () / getValue () invece dei metodi getValue0 () / getValue1 ().

Esempio

Vediamo JavaTuples in azione. Qui vedremo come ottenere valori da una tupla utilizzando vari modi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.KeyValue;
import org.javatuples.Pair;
public class TupleTester {
   public static void main(String args[]){
      //Create using with() method
      Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5));   
      Object value0Obj = pair.getValue(0);
      Object value1Obj = pair.getValue(1);
      String value0 = pair.getValue0();
      Integer value1 = pair.getValue1();
      System.out.println(value0Obj);
      System.out.println(value1Obj);
      System.out.println(value0);
      System.out.println(value1);  
	   KeyValue<String, Integer> keyValue = KeyValue.with(
         "Test", Integer.valueOf(5)
      );
      value0 = keyValue.getKey();
      value1 = keyValue.getValue();
      System.out.println(value0Obj);
      System.out.println(value1Obj);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

Test
5
Test
5
Test
5

Una tupla ha metodi setAtX () per impostare il valore in un indice particolare. Ad esempio, la classe Triplet ha i seguenti metodi.

setAt0() - imposta il valore all'indice 0.
setAt1() - impostare il valore all'indice 1.
setAt2() - impostare il valore all'indice 2.

Caratteristica

Le tuple sono immutabili. Ogni setAtX () restituisce una nuova tupla che deve essere utilizzata per vedere il valore aggiornato.
Il tipo di posizione di una tupla può essere modificato utilizzando il metodo setAtX ().

Esempio

Vediamo JavaTuples in azione. Qui vedremo come impostare i valori in una tupla usando vari modi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Pair;
public class TupleTester {
   public static void main(String args[]){
      //Create using with() method
      Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5));   
      Pair<String, Integer> pair1 = pair.setAt0("Updated Value");
      System.out.println("Original Pair: " + pair);
      System.out.println("Updated Pair:" + pair1);
      Pair<String, String> pair2 = pair.setAt1("Changed Type");
      System.out.println("Original Pair: " + pair);
      System.out.println("Changed Pair:" + pair2);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

Original Pair: [Test, 5]
Updated Pair:[Updated Value, 5]
Original Pair: [Test, 5]
Changed Pair:[Test, Changed Type]

Una tupla ha il metodo add () alla fine di una tupla e cambia anche il tipo di tupla. Ad esempio, l'aggiunta di un elemento alla tupla Triplet lo convertirà in una tupla Quartet.

Quartet<String,String,String,String> quartet = triplet.add("Test");

Una tupla ha anche metodi addAtX () per aggiungere una posizione in un particolare indice a partire da 0.

Quartet<String,String,String,String> quartet = triplet.addAt1("Test");

Una tupla può aggiungere più di un elemento utilizzando i metodi addAtX ().

Quartet<String,String,String,String> quartet = pair.addAt1("Test1", "Test2");

Una tupla può anche aggiungere una tupla utilizzando i metodi addAtX ().

Quartet<String,String,String,String> quartet = pair.addAt1(pair1);

Esempio

Vediamo JavaTuples in azione. Qui vedremo come aggiungere valori in una tupla usando vari modi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Pair;
import org.javatuples.Quartet;
import org.javatuples.Quintet;
import org.javatuples.Triplet;
public class TupleTester {
   public static void main(String args[]){
      Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5));   
      Triplet<String, Integer, String> triplet = pair.add("Test2");
      Quartet<String, String, Integer, String> quartet = triplet.addAt1("Test1");
      Quintet<String, Integer, String, String, Integer> quintet = triplet.add(pair);
      System.out.println("Pair: " + pair);
      System.out.println("Triplet:" + triplet);
      System.out.println("Quartet:" + quartet);
      System.out.println("Quintet:" + quintet);     
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

Pair: [Test, 5]
Triplet:[Test, 5, Test2]
Quartet:[Test, Test1, 5, Test2]
Quintet:[Test, 5, Test2, Test, 5]

Una tupla ha metodi removeAtX () per rimuovere il valore in un particolare indice. Ad esempio, la classe Triplet ha i seguenti metodi.

removeAt0() - rimuove il valore all'indice 0 e restituisce la tupla risultante.
removeAt1() - rimuove il valore all'indice 1 e restituisce la tupla risultante.
removeAt2() - rimuove il valore all'indice 2 e restituisce la tupla risultante.

La rimozione di un elemento restituisce una nuova tupla.

Esempio

Vediamo JavaTuples in azione. Qui vedremo come rimuovere il valore in una tupla.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Pair;
import org.javatuples.Triplet;
public class TupleTester {
   public static void main(String args[]){
      Triplet<String, Integer, String> triplet = Triplet.with(
         "Test1", Integer.valueOf(5), "Test2"
      );
      Pair<String, Integer> pair = triplet.removeFrom2();
      System.out.println("Triplet:" + triplet);
      System.out.println("Pair: " + pair);  
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

Triplet:[Test1, 5, Test2]
Pair: [Test1, 5]

Tupla in elenco / matrice

Una tupla può essere convertita in List / Array ma al costo dell'indipendenza dai tipi e la lista convertita è di tipo List <Object> / Object [].

List<Object> list = triplet.toList();
Object[] array = triplet.toArray();

Raccolta / matrice in tupla

Una raccolta può essere convertita in tupla utilizzando il metodo fromCollection () e l'array può essere convertito in tupla utilizzando il metodo fromArray ().

Pair<String, Integer> pair = Pair.fromCollection(list);
Quartet<String,String,String,String> quartet = Quartet.fromArray(array);

Se la dimensione della matrice / raccolta è diversa da quella della tupla, si verificherà IllegalArgumentException.

Exception in thread "main" java.lang.IllegalArgumentException: 
Array must have exactly 4 elements in order to create a Quartet. Size is 5
   at ...

Esempio

Vediamo JavaTuples in azione. Qui vedremo come convertire la tupla in list / array e viceversa.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.List;
import org.javatuples.Quartet;
import org.javatuples.Triplet;
public class TupleTester {
   public static void main(String args[]){
      Triplet<String, Integer, String> triplet = Triplet.with(
         "Test1", Integer.valueOf(5), "Test2"
      );
      List<Object> list = triplet.toList();
      Object[] array = triplet.toArray();
      System.out.println("Triplet:" + triplet);
      System.out.println("List: " + list);  
      System.out.println();
      for(Object object: array) {
         System.out.print(object + " " );
      }
      System.out.println();
      String[] strArray = new String[] {"a", "b" , "c" , "d"};
      Quartet<String, String, String, String> quartet = Quartet.fromArray(strArray);
      System.out.println("Quartet:" + quartet);      
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

Triplet:[Test1, 5, Test2]
List: [Test1, 5, Test2]

Test1 5 Test2 
Quartet:[a, b, c, d]

Ogni tupla implementa l'interfaccia Iterable e può essere iterata in modo simile alla raccolta.

Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5)); 
for(Object object: Pair){
	System.out.println(object);
}

Esempio

Vediamo JavaTuples in azione. Qui vedremo come iterare le tuple.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Quartet;
import org.javatuples.Triplet;
public class TupleTester {
   public static void main(String args[]){
      Triplet<String, Integer, String> triplet = Triplet.with(
         "Test1", Integer.valueOf(5), "Test2"
      );
      for(Object object: triplet) {
         System.out.print(object + " " );
      }
      System.out.println();
      System.out.println(triplet);
      String[] strArray = new String[] {"a", "b" , "c" , "d"};
      Quartet<String, String, String, String> quartet = Quartet.fromArray(strArray);
      for(Object object: quartet) {
         System.out.print(object + " " );
      }
      System.out.println();
      System.out.println("Quartet:" + quartet);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

Test1 5 Test2 
[Test1, 5, Test2]
a b c d 
Quartet:[a, b, c, d]

Ogni tupla fornisce metodi di utilità per controllare i propri elementi in modo simile alla raccolta.

contains(element) - controlla se l'elemento è presente o meno.
containsAll(collection) - controlla se gli elementi sono presenti o meno.
indexOf(element) - restituisce l'indice del primo elemento se presente altrimenti -1.
lastIndexOf(element) - restituisce l'indice dell'ultimo elemento se presente altrimenti -1.

Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5)); 
boolean isPresent = pair.contains("Test");

Esempio

Vediamo JavaTuples in azione. Qui vedremo come controllare gli elementi in una tupla.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.List;
import org.javatuples.Quartet;
public class TupleTester {
   public static void main(String args[]){
      Quartet<String, Integer, String, String> quartet = Quartet.with(
         "Test1", Integer.valueOf(5), "Test3", "Test3"
      );
      System.out.println(quartet);
      boolean isPresent = quartet.contains(5);
      System.out.println("5 is present: " + isPresent);
      isPresent = quartet.containsAll(List.of("Test1", "Test3"));   
      System.out.println("Test1, Test3 are present: " + isPresent);
      int indexOfTest3 = quartet.indexOf("Test3");
      System.out.println("First Test3 is present at: " + indexOfTest3);
      int lastIndexOfTest3 = quartet.lastIndexOf("Test3");
      System.out.println("Last Test3 is present at: " + lastIndexOfTest3);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[Test1, 5, Test3, Test3]
5 is present: true
Test1, Test3 are present: true
First Test3 is present at: 2
Last Test3 is present at: 3

introduzione

Il org.javatuples.Unit class rappresenta una tupla con un singolo elemento.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per org.javatuples.Unit classe -

public final class Unit<A>
   extends Tuple
      implements IValue0<A>

Costruttori di classi

Sr.No.	Costruttore e descrizione
1	Unit(A value0) Questo crea una tupla unità.

Metodi di classe

Sr.No.	Metodo e descrizione
1	Pair add(Unit tuple) Questo metodo restituisce una tupla Pair. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio add (Pair tuple) restituisce Triplet e upto add (Ennead tuple) restituisce Decade tuple.
2	Pair add(X0 value) Questo metodo aggiunge un valore alla tupla e restituisce una tupla Pair. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio add (X0 valore0, X1 valore1) restituisce Triplet e così via fino a add () con nove parametri.
3	Pair addAt0(Unit value) Questo metodo aggiunge una tupla Unit all'indice 0 e restituisce una tupla Pair. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio addAt0 (valore di coppia) restituisce Triplet e così via fino a addAt0 (Ennead). Altri metodi simili sono addAt1 (valore unitario) che aggiunge un'unità a index0 e hanno metodi simili fino a addAt1 (Ennead).
4	Pair addAt0(X0 value) Questo metodo aggiunge un valore all'indice 0 e restituisce una tupla Pair. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio addAt0 (X0 valore0, X1 valore1) restituisce Triplet e così via fino a addAt0 () con nove parametri. Altri metodi simili sono addAt1 (valore X0) che aggiunge un valore a index0 e hanno metodi simili fino a addAt1 () con nove parametri.
5	static <X> Unit<X> fromArray(X[] array) Crea tupla da array.
6	static <X> Unit<X> fromCollection(Collection<X> collection) Crea tupla dalla raccolta.
7	static <X> Unit<X> fromIterable(Iterable<X> iterable) Crea tupla da iterabile.
8	static <X> Unit<X> fromIterable(Iterable<X> iterable, int index) Crea tupla da iterabile, a partire dall'indice specificato.
9	int getSize() Restituisce la dimensione della tupla.
10	A getValue0() Restituisce il valore della tupla.
11	<X> Unit<X> setAt0(X value) Imposta il valore della tupla.
12	static <A> Unit<A> with(A value0) Crea la tupla usando il valore dato.

I metodi ereditano

Questa classe eredita i metodi dalle seguenti classi:

org.javatuples.Tuple
Object

Esempio

Vediamo Unit Class in azione. Qui vedremo come utilizzare vari metodi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Pair;
import org.javatuples.Unit;
public class TupleTester {
   public static void main(String args[]){
      Unit<Integer> unit = Unit.with(5);
      System.out.println(unit);
      boolean isPresent = unit.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      Pair<Integer, String> pair = unit.add("Test");
      System.out.println(pair);
      Integer value = unit.getValue0();
      System.out.println(value);
      Unit<Integer> unit1 = Unit.fromCollection(list);   
      System.out.println(unit1);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[5]
5 is present: true
[5, Test]
5
[1]

introduzione

Il org.javatuples.Pair class rappresenta una tupla con due elementi.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per org.javatuples.Pair classe -

public final class Pair<A,B>
   extends Tuple
      implements IValue0<A>, IValue1<B>

Costruttore di classe

Sr.No.	Costruttore e descrizione
1	Pair(A value0, B value1) Questo crea una coppia tupla.

Metodi di classe

Allo stesso modo setAt1 () imposta il valore all'indice 1.

Sr.No.	Metodo e descrizione
1	Triplet add(Unit tuple) Questo metodo restituisce una tupla triplet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio add (Pair tuple) restituisce Quartet e upto add (Octet tuple) restituisce Decade tuple.
2	Triplet add(X0 value) Questo metodo aggiunge un valore alla tupla e restituisce una tupla triplet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio add (X0 value0, X1 value1) restituisce Quartet e così via upto add () con otto parametri.
3	Triplet addAt0(Unit value) Questo metodo aggiunge una tupla Unit all'indice 0 e restituisce una tupla triplet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio addAt0 (valore coppia) restituisce Quartet e così via fino a addAt0 (Octet). Altri metodi simili sono addAt1 (Unit value) che aggiunge un'unità a index0 e hanno metodi simili fino a addAt2 (Octet).
4	Triplet addAt0(X0 value) Questo metodo aggiunge un valore all'indice 0 e restituisce una tupla Triplet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio addAt0 (X0 value0, X1 value1) restituisce Quartet e così via fino a addAt0 () con otto parametri. Altri metodi simili sono addAt1 (valore X0) che aggiunge un valore a index0 e hanno metodi simili fino a addAt2 () con otto parametri.
5	static <X> Pair<X,X> fromArray(X[] array) Crea tupla da array.
6	static <X> Pair<X,X> fromCollection(Collection<X> collection) Crea tupla dalla raccolta.
7	static <X> Pair<X,X> fromIterable(Iterable<X> iterable) Crea tupla da iterabile.
8	static <X> Pair<X,X> fromIterable(Iterable<X> iterable, int index) Crea tupla da iterabile, a partire dall'indice specificato.
9	int getSize() Restituisce la dimensione della tupla.
10	A getValue0() Restituisce il valore della tupla all'indice 0. Allo stesso modo getValue1 () restituisce il valore all'indice 1.
11	Unit<B> removeFrom0() Restituisce la tupla dopo aver rimosso il valore della tupla all'indice 0. Allo stesso modo removeFrom1 () restituisce la tupla dopo aver rimosso il valore della tupla all'indice 1.
12	<X> Pair<X,B> setAt0(X value) Imposta il valore della tupla all'indice 0.
13	static <A,B> Pair<A,B> with(A value0, B value1) Crea la tupla usando il valore dato.

I metodi ereditano

Questa classe eredita i metodi dalle seguenti classi:

org.javatuples.Tuple
Object

Esempio

Vediamo Pair Class in azione. Qui vedremo come utilizzare vari metodi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Pair;
import org.javatuples.Triplet;
import org.javatuples.Unit;

public class TupleTester {
   public static void main(String args[]){
      Pair<Integer, Integer> pair = Pair.with(5,6);
      System.out.println(pair);
      boolean isPresent = pair.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      Triplet<Integer,Integer, String> triplet = pair.add("Test");
      System.out.println(triplet);
      Integer value = pair.getValue0();
      System.out.println(value);
      Unit<Integer> unit = pair.removeFrom0();
      System.out.println(unit);
      Pair<Integer, Integer> pair1 = Pair.fromCollection(list);   
      System.out.println(pair1);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[5, 6]
5 is present: true
[5, 6, Test]
5
[6]
[1, 2]

introduzione

Il org.javatuples.Triplet class rappresenta una tupla con tre elementi.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per org.javatuples.Triplet classe -

public final class Triplet<A,B,C>
   extends Tuple
      implements IValue0<A>, IValue1<B>, IValue2<C>

Costruttori di classi

Sr.No.	Costruttore e descrizione
1	Triplet(A value0, B value1, C value2) Questo crea una tripletta tupla.

Metodi di classe

Allo stesso modo setAt1 () upto setAt2 () imposta il valore all'indice 1 e così via.

Sr.No.	Metodo e descrizione
1	Quartet add(Unit tuple) Questo metodo restituisce una tupla Quartet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio add (Pair tuple) restituisce Quintet e upto add (Septet tuple) restituisce Decade tuple.
2	Quartet add(X0 value) Questo metodo aggiunge un valore alla tupla e restituisce una tupla Quartet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio add (X0 value0, X1 value1) restituisce Quintet e così via upto add () con sette parametri.
3	Quartet addAt0(Unit value) Questo metodo aggiunge una tupla Unit all'indice 0 e restituisce una tupla Quartet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad es. AddAt0 (valore coppia) restituisce Quintetto e così via fino a addAt0 (settetto). Un altro metodo simile è addAt1 (valore unitario) che aggiunge un'unità a index0 e ha metodi simili fino a addAt2 (Septet).
4	Quartet addAt0(X0 value) Questo metodo aggiunge un valore all'indice 0 e restituisce una tupla Quartet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio addAt0 (X0 value0, X1 value1) restituisce Quintet e così via fino a addAt0 () con sette parametri. Altri metodi simili sono addAt1 (valore X0) che aggiunge un valore a index0 e hanno metodi simili fino a addAt2 () con sette parametri.
5	static <X> Triplet<X,X,X> fromArray(X[] array) Crea tupla da array.
6	static <X> Triplet<X,X,X> fromCollection(Collection<X> collection) Crea tupla dalla raccolta.
7	static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable) Crea tupla da iterabile.
8	static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable, int index) Crea tupla da iterabile, a partire dall'indice specificato.
9	int getSize() Restituisce la dimensione della tupla.
10	A getValue0() Restituisce il valore della tupla all'indice 0. Allo stesso modo getValue1 () upto getValue2 () restituisce il valore all'indice 1 e così via.
11	Pair<B,C> removeFrom0() Restituisce la tupla dopo aver rimosso il valore della tupla all'indice 0. Allo stesso modo removeFrom1 () fino a removeFrom2 () restituisce la tupla dopo aver rimosso il valore della tupla all'indice 1 e così via.
12	<X> Triplet<X,B,C> setAt0(X value) Imposta il valore della tupla all'indice 0.
13	static <A> Triplet<A,B,C> with(A value0, B value1, C value2) Crea la tupla usando il valore dato.

I metodi ereditano

Questa classe eredita i metodi dalle seguenti classi:

org.javatuples.Tuple
Object

Esempio

Vediamo la classe Triplet in azione. Qui vedremo come utilizzare vari metodi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Pair;
import org.javatuples.Quartet;
import org.javatuples.Triplet;

public class TupleTester {
   public static void main(String args[]){
      Triplet<Integer, Integer, Integer> triplet = Triplet.with(5, 6, 7);
      System.out.println(triplet);
      boolean isPresent = triplet.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      Quartet<Integer, Integer, Integer, String> quartet = triplet.add("Test");
      System.out.println(quartet);
      Integer value = triplet.getValue0();
      System.out.println(value);
      Pair<Integer, Integer> pair = triplet.removeFrom0();
      System.out.println(pair);
      Triplet<Integer, Integer, Integer> triplet1 = 
         Triplet.fromCollection(list);   
      System.out.println(triplet1);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[5, 6, 7]
5 is present: true
[5, 6, 7, Test]
5
[6, 7]
[1, 2, 3]

introduzione

Il org.javatuples.Quartet class rappresenta una tupla con quattro elementi.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per org.javatuples.Quartet classe -

public final class Quartet<A, B, C, D>
   extends Tuple
      implements IValue0<A>, IValue1<B>, IValue2<C>, IValue3<D>

Costruttore di classe

Sr.No.	Costruttore e descrizione
1	Quartet(A value0, B value1, C value2, D value3) Questo crea una tupla di quartetto.

Metodi di classe

Allo stesso modo setAt1 () upto setAt3 () imposta il valore all'indice 1 e così via.

Sr.No.	Metodo e descrizione
1	Quintet add(Unit tuple) Questo metodo restituisce una tupla Quintet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio add (Pair tuple) restituisce Sextet e upto add (Sextet tuple) restituisce Decade tuple.
2	Quintet add(X0 value) Questo metodo aggiunge un valore alla tupla e restituisce una tupla Quintet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio add (X0 value0, X1 value1) restituisce Sextet e così via upto add () con sei parametri.
3	Quintet addAt0(Unit value) Questo metodo aggiunge una tupla Unit all'indice 0 e restituisce una tupla Quintet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio addAt0 (valore della coppia) restituisce Sextet e così via fino a addAt0 (Sextet). Altri metodi simili sono addAt1 (Valore unitario) che aggiunge un'unità a index0 e hanno metodi simili fino a addAt2 (Sextet).
4	Quintet addAt0(X0 value) Questo metodo aggiunge un valore all'indice 0 e restituisce una tupla Quintet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio addAt0 (X0 value0, X1 value1) restituisce Sextet e così via fino a addAt0 () con sei parametri. Altri metodi simili sono addAt1 (valore X0) che aggiunge un valore a index0 e hanno metodi simili fino a addAt2 () con sei parametri.
5	static <X> Quartet<X,X,X,X> fromArray(X[] array) Crea tupla da array.
6	static <X> Quartet<X,X,X,X> fromCollection(Collection<X> collection) Crea tupla dalla raccolta.
7	static <X> Quartet<X,X,X,X> fromIterable(Iterable<X> iterable) Crea tupla da iterabile.
8	static <X> Quartet<X,X,X,X> fromIterable(Iterable<X> iterable, int index) Crea tupla da iterabile, a partire dall'indice specificato.
9	int getSize() Restituisce la dimensione della tupla.
10	A getValue0() Restituisce il valore della tupla all'indice 0. Allo stesso modo getValue1 () upto getValue3 () restituisce il valore all'indice 1 e così via.
11	Triplet<B,C,D> removeFrom0() Restituisce la tupla dopo aver rimosso il valore della tupla all'indice 0. Allo stesso modo removeFrom1 () fino a removeFrom3 () restituisce la tupla dopo aver rimosso il valore della tupla all'indice 1 e così via.
12	<X> Quartet<X,B,C,D> setAt0(X value) Imposta il valore della tupla all'indice 0.
13	static <A> Quartet<A,B,C,D> with(A value0, B value1, C value2, D value3) Crea la tupla usando il valore dato.

I metodi ereditano

Questa classe eredita i metodi dalle seguenti classi:

org.javatuples.Tuple
Object

Esempio

Vediamo Quartet Class in azione. Qui vedremo come utilizzare vari metodi.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Quartet;
import org.javatuples.Quintet;
import org.javatuples.Triplet;

public class TupleTester {
   public static void main(String args[]){
      Quartet<Integer, Integer, Integer, Integer> quartet = Quartet.with(
         5, 6, 7,8
      );
      System.out.println(quartet);
      boolean isPresent = quartet.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      Quintet<Integer, Integer, Integer, Integer, String> quintet = quartet.add("Test");
      System.out.println(quintet);
      Integer value = quartet.getValue0();
      System.out.println(value);
      Triplet<Integer, Integer, Integer> triplet = quartet.removeFrom0();
      System.out.println(triplet);
      Quartet<Integer, Integer, Integer, Integer> quartet1 = Quartet.fromCollection(list);   
      System.out.println(quartet1);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[5, 6, 7, 8]
5 is present: true
[5, 6, 7, 8, Test]
5
[6, 7, 8]
[1, 2, 3, 4]

introduzione

Il org.javatuples.Quintet class rappresenta una tupla con cinque elementi.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per org.javatuples.Quintet classe -

public final class Quintet<A, B, C, D, E>
   extends Tuple
      implements IValue0<A>, IValue1<B>, 
         IValue2<C>, IValue3<D>, IValue4<E>

Costruttore di classe

Sr.No.	Costruttore e descrizione
1	Quintet(A value0, B value1, C value2, D value3, E value4) Questo crea una tupla quintetto.

Metodi di classe

Allo stesso modo setAt1 () upto setAt4 () imposta il valore all'indice 1 e così via.

Sr.No.	Metodo e descrizione
1	Sextet add(Unit tuple) Questo metodo restituisce una tupla Sextet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio add (Pair tuple) restituisce Septet e upto add (Quintet tuple) restituisce Decade tuple.
2	Sextet add(X0 value) Questo metodo aggiunge un valore alla tupla e restituisce una tupla Sextet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio add (X0 value0, X1 value1) restituisce Septet e così via upto add () con cinque parametri.
3	Sextet addAt0(Unit value) Questo metodo aggiunge una tupla Unit all'indice 0 e restituisce una tupla Sextet. Allo stesso modo sono disponibili altri metodi per aggiungere tuple, ad esempio addAt0 (valore coppia) restituisce Septet e così via fino a addAt0 (Quintetto). Altri metodi simili sono addAt1 (valore unitario) che aggiunge un'unità a index0 e hanno metodi simili fino a addAt4 (Quintet).
4	Sextet addAt0(X0 value) Questo metodo aggiunge un valore all'indice 0 e restituisce una tupla Sextet. Allo stesso modo sono disponibili altri metodi per aggiungere valori, ad esempio addAt0 (X0 value0, X1 value1) restituisce Septet e così via fino a addAt0 () con cinque parametri. Altri metodi simili sono addAt1 (valore X0) che aggiunge un valore a index0 e hanno metodi simili fino a addAt4 () con cinque parametri.
5	static <X> Quintet<X,X,X,X,X> fromArray(X[] array) Crea tupla da array.
6	static <X> Quintet<X,X,X,X,X> fromCollection(Collection<X> collection) Crea tupla dalla raccolta.
7	static <X> Quintet<X,X,X,X,X> fromIterable(Iterable<X> iterable) Crea tupla da iterabile.
8	static <X> Quintet<X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Crea tupla da iterabile, a partire dall'indice specificato.
9	int getSize() Restituisce la dimensione della tupla.
10	A getValue0() Restituisce il valore della tupla all'indice 0. Allo stesso modo getValue1 () upto getValue4 () restituisce il valore all'indice 1 e così via.
11	Quartet<B,C,D,E> removeFrom0() Restituisce la tupla dopo aver rimosso il valore della tupla all'indice 0. Allo stesso modo removeFrom1 () fino a removeFrom4 () restituisce la tupla dopo aver rimosso il valore della tupla all'indice 1 e così via.
12	<X> Quintet<X,B,C,D,E> setAt0(X value) Imposta il valore della tupla all'indice 0.
13	static <A> Quintet<A,B,C,D,E> with(A value0, B value1, C value2, D value3, E value4) Crea la tupla usando il valore dato.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see Quintet Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Quartet;
import org.javatuples.Quintet;
import org.javatuples.Sextet;
import org.javatuples.Triplet;

public class TupleTester {
   public static void main(String args[]){
      Quintet<Integer, Integer, Integer, Integer, Integer> quintet 
         = Quintet.with(5, 6, 7,8,9);
      System.out.println(quintet);
      boolean isPresent = quintet.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      list.add(5);
      Sextet<Integer, Integer, Integer, Integer, Integer, String> sextet 
         = quintet.add("Test");
      System.out.println(sextet);
      Integer value = quintet.getValue0();
      System.out.println(value);
      Quartet<Integer, Integer, Integer, Integer> quartet = quintet.removeFrom0();
      System.out.println(quartet);
      Quintet<Integer, Integer, Integer, Integer, Integer> quintet1 
         = Quintet.fromCollection(list);   
      System.out.println(quintet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9]
5 is present: true
[5, 6, 7, 8, 9, Test]
5
[6, 7, 8, 9]
[1, 2, 3, 4, 5]

Introduction

The org.javatuples.Sextet class represents a Tuple with six elements.

Class Declaration

Following is the declaration for org.javatuples.Sextet class −

public final class Sextet<A, B, C, D, E, F>
   extends Tuple
      implements IValue0<A>, IValue1<B>, 
         IValue2<C>, IValue3<D>, IValue4<E>,
            IValue5<F>

Class Constructor

Sr.No.	Constructor & Description
1	Sextet(A value0, B value1, C value2, D value3, E value4, F value5) This creates a Sextet Tuple.

Class Methods

Similarly setAt1() upto setAt5() set the value at index 1, and so on.

Sr.No.	Method & Description
1	Septet add(Unit tuple) This method returns a Septet tuple. Similarly other methods to add tuples are available e.g. add(Pair tuple) returns Octet and upto add(Quartet tuple) returns Decade tuple.
2	Septet add(X0 value) This method add a value to the tuple and returns a Septet tuple. Similarly other methods to add values are available e.g. add(X0 value0, X1 value1) returns Octet and so on upto add() with four parameters.
3	Septet addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Septet tuple. Similarly other methods to add tuples are available e.g. addAt0(Pair value) returns Octet and so on upto addAt0(Quartet). Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt5(Quartet).
4	Septet addAt0(X0 value) This method add a value at index 0 and returns a Septet tuple. Similarly other methods to add values are available e.g. addAt0(X0 value0, X1 value1) returns Octet and so on upto addAt0() with four parameters. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt5() with four parameters.
5	static <X> Sextet<X,X,X,X,X,X> fromArray(X[] array) Create tuple from array.
6	static <X> Sextet<X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection.
7	static <X> Sextet<X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
8	static <X> Sextet<X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
9	int getSize() Return the size of the tuple.
10	A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue5() returns the value at index 1 and so on.
11	Quintet<B,C,D,E,F> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom5() returns the tuple after removing value of the tuple at index 1 and so on.
12	<X> Sextet<X,B,C,D,E,F> setAt0(X value) Set the value of the tuple at index 0.
13	static <A> Sextet<A,B,C,D,E,F> with(A value0, B value1, C value2, D value3, E value4, F value5) Create the tuple using given value.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see Sextet Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Quartet;
import org.javatuples.Quintet;
import org.javatuples.Sextet;
import org.javatuples.Septet;
public class TupleTester {
   public static void main(String args[]){
      Sextet<Integer, Integer, Integer, Integer, Integer,Integer> sextet 
         = Sextet.with(5, 6, 7,8,9,10);
      System.out.println(sextet);
      boolean isPresent = sextet.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      list.add(5);
      list.add(6);
      Septet<Integer, Integer, Integer, Integer, Integer, Integer, String> septet 
         = sextet.add("Test");
      System.out.println(septet);
      Integer value = sextet.getValue0();
      System.out.println(value);
      Quintet<Integer, Integer, Integer, Integer,Integer> quintet 
         = sextet.removeFrom0();
      System.out.println(quintet);
      Sextet<Integer, Integer, Integer, Integer, Integer,Integer> sextet1 
         = Sextet.fromCollection(list);   
      System.out.println(sextet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10]
5 is present: true
[5, 6, 7, 8, 9, 10, Test]
5
[6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6]

Introduction

The org.javatuples.Septet class represents a Tuple with seven elements.

Class Declaration

Following is the declaration for org.javatuples.Septet class −

public final class Septet<A, B, C, D, E, F, G>
   extends Tuple
      implements IValue0<A>, IValue1<B>, 
         IValue2<C>, IValue3<D>, IValue4<E>,
            IValue5<F>, IValue6<G>

Class Constructor

Sr.No.	Constructor & Description
1	Septet(A value0, B value1, C value2, D value3, E value4, F value5, G value6) This creates a Septet Tuple.

Class Methods

Similarly setAt1() upto setAt6() set the value at index 1, and so on.

Sr.No.	Method & Description
1	Octet add(Unit tuple) This method returns a Octet tuple. Similarly other methods to add tuples are available e.g. add(Pair tuple) returns Ennead and upto add(Triplet tuple) returns Decade tuple.
2	Octet add(X0 value) This method add a value to the tuple and returns a Octet tuple. Similarly other methods to add values are available e.g. add(X0 value0, X1 value1) returns Ennead and so on upto add() with three parameters.
3	Octet addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Octet tuple. Similarly other methods to add tuples are available e.g. addAt0(Pair value) returns Ennead and so on upto addAt0(Triplet). Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt6(Triplet).
4	Octet addAt0(X0 value) This method add a value at index 0 and returns a Octet tuple. Similarly other methods to add values are available e.g. addAt0(X0 value0, X1 value1) returns Ennead and so on upto addAt0() with three parameters. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt6() with three parameters.
5	static <X> Septet<X,X,X,X,X,X,X> fromArray(X[] array) Create tuple from array.
6	static <X> Septet<X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection.
7	static <X> Septet<X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
8	static <X> Septet<X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
9	int getSize() Return the size of the tuple.
10	A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue6() returns the value at index 1 and so on.
11	Sextet<B,C,D,E,F,G> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom6() returns the tuple after removing value of the tuple at index 1 and so on.
12	<X> Septet<X,B,C,D,E,F,G> setAt0(X value) Set the value of the tuple at index 0.
13	static <A> Septet<A,B,C,D,E,F,G> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6) Create the tuple using given value.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see Septet Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Septet;
import org.javatuples.Sextet;
import org.javatuples.Octet;
public class TupleTester {
   public static void main(String args[]){
      Septet<Integer, Integer, Integer, Integer, Integer,Integer,Integer> septet 
         = Septet.with(5, 6, 7,8,9,10,11);
      System.out.println(septet);
      boolean isPresent = septet.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      list.add(5);
      list.add(6);
      list.add(7);
      Octet<Integer, Integer, Integer, Integer, Integer, Integer, Integer, String> octet 
         = septet.add("Test");
      System.out.println(octet);
      Integer value = septet.getValue0();
      System.out.println(value);
      Sextet<Integer, Integer, Integer, Integer,Integer, Integer> sextet 
         = septet.removeFrom0();
      System.out.println(sextet);
      Septet<Integer, Integer, Integer, Integer, Integer,Integer, Integer> septet1 
         = Septet.fromCollection(list);   
      System.out.println(septet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10, 11]
5 is present: true
[5, 6, 7, 8, 9, 10, 11, Test]
5
[6, 7, 8, 9, 10, 11]
[1, 2, 3, 4, 5, 6, 7]

Introduction

The org.javatuples.Octet class represents a Tuple with eight elements.

Class Declaration

Following is the declaration for org.javatuples.Octet class −

public final class Octet<A, B, C, D, E, F, G, H>
   extends Tuple
      implements IValue0<A>, IValue1<B>, 
         IValue2<C>, IValue3<D>, IValue4<E>,
            IValue5<F>, IValue6<G>, IValue7<H>

Class Constructor

Sr.No.	Constructor & Description
1	Octet(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7) This creates a Octet Tuple.

Class Methods

Similarly setAt1() upto setAt7() set the value at index 1, and so on.

Sr.No.	Method & Description
1	Ennead add(Unit tuple) This method returns a Ennead tuple. Similarly other methods to add tuples are available e.g. add(Pair tuple) returns Decade.
2	Ennead add(X0 value) This method add a value to the tuple and returns a Ennead tuple. Similarly other methods to add values are available e.g. add(X0 value0, X1 value1) returns Decade.
3	Ennead addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Ennead tuple. Similarly other methods to add tuples are available e.g. addAt0(Pair value) returns Decade. Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt7(Pair).
4	Ennead addAt0(X0 value) This method add a value at index 0 and returns a Ennead tuple. Similarly other methods to add values are available e.g. addAt0(X0 value0, X1 value1) returns Decade. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt7() with two parameters.
5	static <X> Octet<X,X,X,X,X,X,X,X> fromArray(X[] array) Create tuple from array.
6	static <X> Octet<X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection.
7	static <X> Octet<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
8	static <X> Octet<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
9	int getSize() Return the size of the tuple.
10	A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue7() returns the value at index 1 and so on.
11	Septet<B,C,D,E,F,G,H> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom7() returns the tuple after removing value of the tuple at index 1 and so on.
12	<X> Octet<X,B,C,D,E,F,G,H> setAt0(X value) Set the value of the tuple at index 0.
13	static <A> Octet<A,B,C,D,E,F,G,H> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7) Create the tuple using given value.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see Octet Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Ennead;
import org.javatuples.Octet;
import org.javatuples.Septet;
public class TupleTester {
   public static void main(String args[]){
      Octet<Integer, Integer, Integer, Integer, Integer,Integer,Integer,Integer>
      octet = Octet.with(5, 6, 7,8,9,10,11,12);
      System.out.println(octet);
      boolean isPresent = octet.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      list.add(5);
      list.add(6);
      list.add(7);
      list.add(8);
      Ennead<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, String>
      ennead = octet.add("Test");
      System.out.println(ennead);
      Integer value = octet.getValue0();
      System.out.println(value);
      Septet<Integer, Integer, Integer, Integer,Integer, Integer,Integer>
      septet = octet.removeFrom0();
      System.out.println(septet);
      Octet<Integer, Integer, Integer, Integer, Integer,Integer, Integer, Integer> 
      octet1 = Octet.fromCollection(list);   
      System.out.println(octet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10, 11, 12]
5 is present: true
[5, 6, 7, 8, 9, 10, 11, 12, Test]
5
[6, 7, 8, 9, 10, 11, 12]
[1, 2, 3, 4, 5, 6, 7, 8]

Introduction

The org.javatuples.Ennead class represents a Tuple with nine elements.

Class Declaration

Following is the declaration for org.javatuples.Ennead class −

public final class Ennead<A, B, C, D, E, F, G, H, I>
   extends Tuple
      implements IValue0<A>, IValue1<B>, 
         IValue2<C>, IValue3<D>, IValue4<E>,
            IValue5<F>, IValue6<G>, IValue7<H>,
               IValue8<I>

Class Constructor

Sr.No.	Constructor & Description
1	Ennead(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8) This creates a Ennead Tuple.

Class Methods

Similarly setAt1() upto setAt8() set the value at index 1, and so on.

Sr.No.	Method & Description
1	Decade add(Unit tuple) This method returns a Decade tuple.
2	Decade add(X0 value) This method add a value to the tuple and returns a Decade tuple.
3	Decade addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Decade tuple. Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt8(Unit).
4	Decade addAt0(X0 value) This method add a value at index 0 and returns a Decade tuple. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt8() with one parameter.
5	static <X> Ennead<X,X,X,X,X,X,X,X,X > fromArray(X[] array) Create tuple from array.
6	static <X> Ennead<X,X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection.
7	static <X> Ennead<X,X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
8	static <X> Ennead<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
9	int getSize() Return the size of the tuple.
10	A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue8() returns the value at index 1 and so on.
11	Octet<B,C,D,E,F,G,H,I> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom8() returns the tuple after removing value of the tuple at index 1 and so on.
12	<X> Ennead<X,B,C,D,E,F,G,H,I> setAt0(X value) Set the value of the tuple at index 0.
13	static <A> Ennead<A,B,C,D,E,F,G,H,I> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8) Create the tuple using given value.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see Ennead Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;
import org.javatuples.Decade;
import org.javatuples.Ennead;
import org.javatuples.Octet;
public class TupleTester {
   public static void main(String args[]){
      Ennead<Integer, Integer, Integer, Integer, Integer,
         Integer,Integer,Integer, Integer> 
      ennead = Ennead.with(5, 6, 7,8,9,10,11,12,13);
      System.out.println(ennead);
      boolean isPresent = ennead.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      list.add(5);
      list.add(6);
      list.add(7);
      list.add(8);
      list.add(9);
      Decade<Integer, Integer, Integer, Integer, Integer, 
         Integer, Integer, Integer, Integer, String> decade = ennead.add("Test");
      System.out.println(decade);
      Integer value = ennead.getValue0();
      System.out.println(value);
      Octet<Integer, Integer, Integer, Integer,Integer, 
         Integer,Integer, Integer> octet = ennead.removeFrom0();
      System.out.println(octet);
      Ennead<Integer, Integer, Integer, Integer, Integer,
         Integer, Integer, Integer,Integer> ennead1 = Ennead.fromCollection(list);   
      System.out.println(ennead1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10, 11, 12, 13]
5 is present: true
[5, 6, 7, 8, 9, 10, 11, 12, 13, Test]
5
[6, 7, 8, 9, 10, 11, 12, 13]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Introduction

The org.javatuples.Decade class represents a Tuple with ten elements.

Class Declaration

Following is the declaration for org.javatuples.Decade class −

public final class Decade<A, B, C, D, E, F, G, H, I, J>
   extends Tuple
      implements IValue0<A>, IValue1<B>, 
         IValue2<C>, IValue3<D>, IValue4<E>,
            IValue5<F>, IValue6<G>, IValue7<H>,
               IValue8<I>, IValue9<J>

Class Constructor

Sr.No.	Constructor & Description
1	Decade(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8, I value9 ) This creates a Decade Tuple.

Class Methods

Similarly setAt1() upto setAt9() set the value at index 1, and so on.

Sr.No.	Method & Description
1	static <X> Decade<X,X,X,X,X,X,X,X,X,X > fromArray(X[] array) Create tuple from array.
2	static <X> Decade<X,X,X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection.
3	static <X> Decade<X,X,X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
4	static <X> Decade<X,X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
5	int getSize() Return the size of the tuple.
6	A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue9() returns the value at index 1 and so on.
7	Ennead<B,C,D,E,F,G,H,I,J> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom9() returns the tuple after removing value of the tuple at index 1 and so on.
8	<X> Decade<X,B,C,D,E,F,G,H,I,J> setAt0(X value) Set the value of the tuple at index 0.
9	static <A> Decade<A,B,C,D,E,F,G,H,I,J> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8, I value9) Create the tuple using given value.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see Ennead Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Decade;
import org.javatuples.Ennead;
public class TupleTester {
   public static void main(String args[]){
      Decade<Integer, Integer, Integer, Integer, 
         Integer,Integer,Integer,Integer, Integer, Integer> 
      decade = Decade.with(5, 6, 7,8,9,10,11,12,13,14);
      System.out.println(decade);
      boolean isPresent = decade.contains(5);
      System.out.println("5 is present: " + isPresent);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(4);
      list.add(5);
      list.add(6);
      list.add(7);
      list.add(8);
      list.add(9);
      list.add(10);
      Integer value = decade.getValue0();
      System.out.println(value);
      Ennead<Integer, Integer, Integer, Integer,Integer, 
         Integer,Integer, Integer, Integer> ennead = decade.removeFrom0();
      System.out.println(ennead);
      Decade<Integer, Integer, Integer, Integer, Integer,
         Integer, Integer, Integer,Integer, Integer> 
         decade1 = Decade.fromCollection(list);   
      System.out.println(decade1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
5 is present: true
5
[6, 7, 8, 9, 10, 11, 12, 13, 14]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Introduction

The org.javatuples.LabelValue class represents a Tuple with two elements with positions 0 and 1 renamed as "label" and "value", respectively.

Class Declaration

Following is the declaration for org.javatuples.LabelValue class −

public final class LabelValue<A,B>
   extends Tuple
      implements IValue0<A>, IValue1<B>

Class Constructor

Sr.No.	Constructor & Description
1	LabelValue(A value0, B value1) This creates a LabelValue Tuple.

Class Methods

Sr.No.	Method & Description
1	static <X> LabelValue<X,X> fromArray(X[] array) Create tuple from array.
2	static <X> LabelValue<X,X> fromCollection(Collection<X> collection) Create tuple from collection.
3	static <X> LabelValue<X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
4	static <X> LabelValue<X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
5	A getLabel() Return the label.
6	int getSize() Return the size of the tuple.
7	A getValue() Returns the value of the tuple.
8	<X> LabelValue<X,B> setLabel(X label) set the label and return the tuple.
9	<X> LabelValue<A,Y> setValue(Y value) set the value and return the tuple.
10	static <A,B> LabelValue<A,B> with(A value0, B value1) Create the tuple using given value.

Methods inherits

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see LabelValue Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.LabelValue;
public class TupleTester {
   public static void main(String args[]){
      LabelValue<Integer, Integer> labelValue = LabelValue.with(5,6);
      System.out.println(labelValue);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      Integer label = labelValue.getLabel();
      System.out.println(label);
      Integer value = labelValue.getValue();
      System.out.println(value);
      LabelValue<Integer, Integer> labelValue1 
         = LabelValue.fromCollection(list);   
      System.out.println(labelValue1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6]
5
6
[1, 2]

Introduction

The org.javatuples.KeyValue class represents a Tuple with two elements with positions 0 and 1 renamed as "key" and "value", respectively.

Class Declaration

Following is the declaration for org.javatuples.KeyValue class −

public final class KeyValue<A,B>
   extends Tuple
      implements IValue0<A>, IValue1<B>

Class Constructor

Sr.No.	Constructor & Description
1	KeyValue(A value0, B value1) This creates a KeyValue Tuple.

Class Methods

Sr.No.	Method & Description
1	static <X> KeyValue<X,X> fromArray(X[] array) Create tuple from array.
2	static <X> KeyValue<X,X> fromCollection(Collection<X> collection) Create tuple from collection.
3	static <X> KeyValue<X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable.
4	static <X> KeyValue<X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index.
5	A getKey() Return the key.
6	int getSize() Return the size of the tuple.
7	A getValue() Returns the value of the tuple.
8	<X> KeyValue<X,B> setKey(X key) set the label and return the tuple.
9	<X> KeyValue<A,Y> setValue(Y value) set the value and return the tuple.
10	static <A,B> KeyValue<A,B> with(A value0, B value1) Create the tuple using given value.

Methods inherite

This class inherits methods from the following classes −

org.javatuples.Tuple
Object

Example

Let's see KeyValue Class in action. Here we'll see how to use various methods.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.KeyValue;
public class TupleTester {
   public static void main(String args[]){
      KeyValue<Integer, Integer> keyValue = KeyValue.with(5,6);
      System.out.println(keyValue);
      List<Integer> list = new ArrayList<>();
      list.add(1);
      list.add(2);
      Integer key = KeyValue.getKey();
      System.out.println(key);
      Integer value = KeyValue.getValue();
      System.out.println(value);
      KeyValue<Integer, Integer> keyValue1 = KeyValue.fromCollection(list);   
      System.out.println(keyValue1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6]
5
6
[1, 2]

Problem Description

How to implement Pair class using Unit class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Pair;
import org.javatuples.Unit;
public class TupleTester {
   public static void main(String args[]){
      Unit<Integer> unit = Unit.with(5);
      System.out.println(unit);
      Pair<Integer, String> pair = unit.add("test");
      Pair<String, Integer> pair1 = unit.addAt0("test");
      System.out.println(pair);
      System.out.println(pair1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5]
[5, test]
[test, 5]

Problem Description

How to implement Triplet class using Pair class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Triplet;
import org.javatuples.Pair;
public class TupleTester {
   public static void main(String args[]){
      Pair<Integer, Integer> pair = Pair.with(5,6);
      System.out.println(pair);
      Triplet<Integer, Integer, String> triplet = pair.add("test");
      Triplet<String, Integer, Integer> triplet1 = pair.addAt0("test");
      System.out.println(triplet);
      System.out.println(triplet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6]
[5, 6, test]
[test, 5, 6]

Problem Description

How to implement Quartet class using Triplet class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Quartet;
import org.javatuples.Triplet;
public class TupleTester {
   public static void main(String args[]){
      Triplet<Integer, Integer, Integer> triplet = Triplet.with(5,6,7);
      System.out.println(triplet);
      Quartet<Integer, Integer, Integer, String> quartet = triplet.add("test");
      Quartet<String, Integer, Integer, Integer> quartet1 = triplet.addAt0("test");
      System.out.println(quartet);
      System.out.println(quartet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7]
[5, 6, 7, test]
[test, 5, 6, 7]

Problem Description

How to implement Quintet class using Quartet class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Quintet;
import org.javatuples.Quartet;
public class TupleTester {
   public static void main(String args[]){
      Quartet<Integer, Integer, Integer, Integer> quartet = Quartet.with(5,6,7,8);
      System.out.println(quartet);
      Quintet<Integer, Integer, Integer, Integer, String> quintet = quartet.add("test");
      Quintet<String, Integer, Integer, Integer, Integer> quintet1 = quartet.addAt0("test");
      System.out.println(quintet);
      System.out.println(quintet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8]
[5, 6, 7, 8, test]
[test, 5, 6, 7, 8]

Problem Description

How to implement Sextet class using Quintet class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Quintet;
import org.javatuples.Sextet;
public class TupleTester {
   public static void main(String args[]){
      Quintet<Integer, Integer, Integer, Integer, Integer> quintet 
         = Quintet.with(5,6,7,8,9);
      System.out.println(quintet);
      Sextet<Integer, Integer, Integer, Integer, Integer, String> sextet 
         = quintet.add("test");
      Sextet<String, Integer, Integer, Integer, Integer, Integer> sextet1 
         = quintet.addAt0("test");
      System.out.println(sextet);
      System.out.println(sextet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9]
[5, 6, 7, 8, 9, test]
[test, 5, 6, 7, 8, 9]

Problem Description

How to implement Septet class using Sextet class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Septet;
import org.javatuples.Sextet;
public class TupleTester {
   public static void main(String args[]){
      Sextet<Integer, Integer, Integer, Integer, Integer, Integer> sextet 
         = Sextet.with(5,6,7,8,9,10);
      System.out.println(sextet);
      Septet<Integer, Integer, Integer, Integer, Integer, Integer, String> 
         septet = sextet.add("test");
      Septet<String, Integer, Integer, Integer, Integer, Integer, Integer> 
         septet1 = sextet.addAt0("test");
      System.out.println(septet);
      System.out.println(septet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10]
[5, 6, 7, 8, 9, 10, test]
[test, 5, 6, 7, 8, 9, 10]

Problem Description

How to implement Octet class using Septet class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Octet;
import org.javatuples.Septet;
public class TupleTester {
   public static void main(String args[]){
      Septet<Integer, Integer, Integer, Integer, Integer, Integer,
         Integer> septet = Septet.with(5,6,7,8,9,10,11);
      System.out.println(septet);
      Octet<Integer, Integer, Integer, Integer, Integer, Integer, 
         Integer, String> octet = septet.add("test");
      Octet<String, Integer, Integer, Integer, Integer, Integer, 
         Integer, Integer> octet1 = septet.addAt0("test");
      System.out.println(octet);
      System.out.println(octet1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Now run the TupleTester to see the result −

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Output

Verify the Output

[5, 6, 7, 8, 9, 10, 11]
[5, 6, 7, 8, 9, 10, 11, test]
[test, 5, 6, 7, 8, 9, 10, 11]

Problem Description

How to implement Ennead class using Octet class?

Example

Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.

Create a java class file named TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Ennead;
import org.javatuples.Octet;
public class TupleTester {
   public static void main(String args[]){
      Octet<Integer, Integer, Integer, Integer, Integer, Integer,
         Integer, Integer> octet = Octet.with(5,6,7,8,9,10,11,12);
      System.out.println(octet);
      Ennead<Integer, Integer, Integer, Integer, Integer, Integer, 
         Integer, Integer, String> ennead = octet.add("test");
      Ennead<String, Integer, Integer, Integer, Integer, Integer, 
         Integer, Integer, Integer> ennead1 = octet.addAt0("test");
      System.out.println(ennead);
      System.out.println(ennead1);
   }
}

Verify the result

Compile the classes using javac compiler as follows −

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[5, 6, 7, 8, 9, 10, 11, 12]
[5, 6, 7, 8, 9, 10, 11, 12, test]
[test, 5, 6, 7, 8, 9, 10, 11, 12]

Descrizione del problema

Come implementare la classe Decade usando la classe Ennead?

Esempio

L'esempio seguente mostra come eseguire l'attività di cui sopra. Ogni tupla dispone dei metodi add () e addAtX () per convertire la tupla.

Crea un file di classe java denominato TupleTester in C:\>JavaTuples.

File: TupleTester.java

package com.tutorialspoint;
import org.javatuples.Decade;
import org.javatuples.Ennead;
public class TupleTester {
   public static void main(String args[]){
      Ennead<Integer, Integer, Integer, Integer, Integer, Integer,
         Integer, Integer, Integer> ennead = Ennead.with(5,6,7,8,9,10,11,12,13);
      System.out.println(ennead);
      Decade<Integer, Integer, Integer, Integer, Integer, Integer, 
         Integer, Integer, Integer, String> decade = ennead.add("test");
      
      Decade<String, Integer, Integer, Integer, Integer, Integer, 
         Integer, Integer, Integer, Integer> decade1 = ennead.addAt0("test");
      
      System.out.println(decade);
      System.out.println(decade1);
   }
}

Verify the result

Compila le classi usando javac compilatore come segue -

C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java

Ora esegui TupleTester per vedere il risultato -

C:\JavaTuples>java  -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTester

Produzione

Verifica l'output

[5, 6, 7, 8, 9, 10, 11, 12, 13]
[5, 6, 7, 8, 9, 10, 11, 12, 13, test]
[test, 5, 6, 7, 8, 9, 10, 11, 12, 13]