JavaTuples - Guia rápido

Tupla

Tupla é uma sequência de objetos que podem ou não ser do mesmo tipo. Considere o seguinte exemplo -

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

O objeto acima é uma tupla de três elementos, um inteiro, uma string e um objeto de conexão.

JavaTuple

JavaTuples é uma biblioteca muito simples que oferece dez classes de tupla diferentes que são suficientes para lidar com a maioria dos requisitos relacionados à tupla.

  • Unidade <A> - 1 elemento

  • Par <A, B> - 2 elementos

  • Tripleto <A, B, C> - 3 elementos

  • Quarteto <A, B, C, D> - 4 elementos

  • Quinteto <A, B, C, D, E> - 5 elementos

  • Sexteto <A, B, C, D, E, F> - 6 elementos

  • Septeto <A, B, C, D, E, F, G> - 7 elementos

  • Octeto <A, B, C, D, E, F, G, H> - 8 elementos

  • Enead <A, B, C, D, E, F, G, H, I> - 9 elementos

  • Década <A, B, C, D, E, F, G, H, I, J> - 10 elementos

Além dessas classes de tupla, JavaTuples também fornece duas classes adicionais para fins semânticos.

  • KeyValue<A,B>

  • LabelValue<A,B>

Todas as classes de tupla são seguras de tipo e imutáveis ​​e implementam as seguintes interfaces e métodos.

  • Iterable

  • Serializable

  • Comparable<Tuple>

  • equals()

  • hashCode()

  • toString()

Tupla vs Lista / Matriz

List ou Array podem conter qualquer número de elementos, mas cada elemento deve ser do mesmo tipo, enquanto as tuplas podem conter apenas um número específico de elementos, podem ter diferentes tipos de elementos, mas ainda são de tipos diferentes.

Configuração de ambiente local

Se você ainda deseja configurar seu ambiente para a linguagem de programação Java, esta seção o orienta sobre como fazer download e configurar o Java em sua máquina. Siga as etapas mencionadas abaixo para configurar o ambiente.

Java SE está disponível gratuitamente no link Download Java . Portanto, você baixa uma versão com base em seu sistema operacional.

Siga as instruções para baixar o Java e executar o .exepara instalar o Java em sua máquina. Depois de instalar o Java em sua máquina, você precisará definir variáveis ​​de ambiente para apontar para os diretórios de instalação corretos -

Configurando o caminho para Windows 2000 / XP

Estamos assumindo que você instalou o Java no diretório c: \ Arquivos de programas \ java \ jdk -

  • Clique com o botão direito em 'Meu Computador' e selecione 'Propriedades'.

  • Clique no botão 'Variáveis ​​de ambiente' na guia 'Avançado'.

  • Agora, altere a variável 'Path' para que também contenha o caminho para o executável Java. Exemplo, se o caminho está definido atualmente para 'C: \ WINDOWS \ SYSTEM32', altere seu caminho para 'C: \ WINDOWS \ SYSTEM32; c: \ Arquivos de programas \ java \ jdk \ bin'.

Configurando o Caminho para Windows 95/98 / M

Estamos assumindo que você instalou o Java no diretório c: \ Arquivos de programas \ java \ jdk -

  • Edite o arquivo 'C: \ autoexec.bat' e adicione a seguinte linha no final - 'SET PATH =% PATH%; C: \ Arquivos de programas \ java \ jdk \ bin'

Configurando o caminho para Linux, UNIX, Solaris, FreeBS

A variável de ambiente PATH deve ser definida para apontar para onde os binários Java foram instalados. Consulte a documentação do shell se tiver problemas para fazer isso.

Por exemplo, se você usar bash como seu shell, então você adicionaria a seguinte linha ao final de seu '.bashrc: export PATH = / path / to / java: $ PATH'

Editor Java popular

Para escrever seus programas Java, você precisa de um editor de texto. Existem muitos IDEs sofisticados disponíveis no mercado. Mas, por agora, você pode considerar um dos seguintes -

  • Notepad - Na máquina Windows você pode usar qualquer editor de texto simples como o Notepad (recomendado para este tutorial), TextPad.

  • Netbeans- É um IDE Java de código aberto e gratuito que pode ser baixado em www.netbeans.org/index.html .

  • Eclipse- Também é um IDE Java desenvolvido pela comunidade de código aberto eclipse e pode ser baixado de www.eclipse.org .

Baixe JavaTuples Archie

Baixe a versão mais recente do arquivo jar JavaTuples do Repositório Maven - JavaTuples . Neste tutorial, javatuples-1.2.jar é baixado e copiado para a pasta C: \> javatuples.

SO Nome do arquivo
janelas javatuples-1.2.jar
Linux javatuples-1.2.jar
Mac javatuples-1.2.jar

Definir ambiente JavaTuples

Colocou o JavaTuplesvariável de ambiente para apontar para o local do diretório base onde o jar JavaTuples está armazenado em sua máquina. Supondo que extraímos javatuples-1.2.jar na pasta JavaTuples em vários sistemas operacionais como segue.

SO Resultado
janelas Defina a variável de ambiente JavaTuples como C: \ JavaTuples
Linux export JavaTuples = / usr / local / JavaTuples
Mac export JavaTuples = / Library / JavaTuples

Definir variável CLASSPATH

Colocou o CLASSPATHvariável de ambiente para apontar para o local do jar JavaTuples. Supondo que você tenha armazenado javatuples-1.2.jar na pasta JavaTuples em vários sistemas operacionais como segue.

SO Resultado
janelas Defina a variável de ambiente CLASSPATH como% CLASSPATH%;% JavaTuples% \ javatuples-1.2.jar;.;
Linux export CLASSPATH = $ CLASSPATH: $ JavaTuples / javatuples-1.2.jar :.
Mac export CLASSPATH = $ CLASSPATH: $ JavaTuples / javatuples-1.2.jar :.

Uma tupla usando classes JavaTuple pode ser criada usando várias opções. A seguir estão os exemplos -

Usando métodos with ()

Cada classe de tupla possui um método with () com parâmetros correspondentes. Por exemplo -

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

Usando Construtor

Cada classe de tupla possui um construtor com parâmetros correspondentes. Por exemplo -

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

Usando coleções

Cada classe de tupla possui um método fromCollection () com parâmetros correspondentes. Por exemplo -

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

Usando Iterable

Cada classe de tupla tem um método fromIterable () para obter elementos de maneira genérica. Por exemplo -

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

Exemplo

Vamos ver o JavaTuples em ação. Aqui, veremos como criar tupels de várias maneiras.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Uma tupla possui métodos getValueX () para obter valores e getValue () um método genérico para obter valor por índice. Por exemplo, a classe Triplet tem os seguintes métodos.

  • getValue(index) - retorna o valor no índice começando em 0.

  • getValue0() - retorna o valor no índice 0.

  • getValue1() - retorna o valor no índice 1.

  • getValue2() - retorna o valor no índice 2.

Característica

  • Os métodos getValueX () são typesafe e nenhum cast é necessário, mas getValue (index) é genérico.

  • Uma tupla tem métodos getValueX () até a contagem de elementos. Por exemplo, Triplet não tem o método getValue3 (), mas o Quartet tem.

  • As classes semânticas KeyValue e LabelValue possuem os métodos getKey () / getValue () e getLabel () / getValue () em vez dos métodos getValue0 () / getValue1 ().

Exemplo

Vamos ver o JavaTuples em ação. Aqui, veremos como obter valores de uma tupla de várias maneiras.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

Test
5
Test
5
Test
5

Uma tupla possui métodos setAtX () para definir o valor em um índice específico. Por exemplo, a classe Triplet tem os seguintes métodos.

  • setAt0() - definir o valor no índice 0.

  • setAt1() - definir o valor no índice 1.

  • setAt2() - definir o valor no índice 2.

Característica

  • As tuplas são imutáveis. Cada setAtX () retorna uma nova tupla que deve ser usada para ver o valor atualizado.

  • O tipo de posição de uma tupla pode ser alterado usando o método setAtX ().

Exemplo

Vamos ver o JavaTuples em ação. Aqui, veremos como definir valores em uma tupla de várias maneiras.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Uma tupla tem o método add () no final de uma tupla e ele altera o tipo de tupla também. Por exemplo, adicionar um elemento à tupla Triplet irá convertê-lo em uma tupla Quartet.

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

Uma tupla também possui métodos addAtX () para adicionar uma posição em um índice específico a partir de 0.

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

Uma tupla pode adicionar mais de um elemento usando métodos addAtX ().

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

Uma tupla também pode adicionar uma tupla usando métodos addAtX ().

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

Exemplo

Vamos ver o JavaTuples em ação. Aqui, veremos como adicionar valores em uma tupla de várias maneiras.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Uma tupla possui métodos removeAtX () para remover o valor de um índice específico. Por exemplo, a classe Triplet tem os seguintes métodos.

  • removeAt0() - remove o valor no índice 0 e retorna a tupla resultante.

  • removeAt1() - remove o valor no índice 1 e retorna a tupla resultante.

  • removeAt2() - remove o valor no índice 2 e retorna a tupla resultante.

Remover um elemento retorna uma nova tupla.

Exemplo

Vamos ver o JavaTuples em ação. Aqui veremos como remover o valor em uma tupla.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Tupla para listar / matriz

Uma tupla pode ser convertida em List / Array, mas ao custo de segurança de tipo e lista convertida é do tipo List <Object> / Object [].

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

Coleção / matriz para tupla

Uma coleção pode ser convertida em tupla usando o método fromCollection () e o array pode ser convertido em tupla usando o método fromArray ().

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

Se o tamanho da matriz / coleção for diferente do tamanho da tupla, então ocorrerá IllegalArgumentException.

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

Exemplo

Vamos ver o JavaTuples em ação. Aqui veremos como converter tupla em lista / array e vice-versa.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

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

Cada tupla implementa a interface Iterable e pode ser iterada de maneira semelhante à coleção.

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

Exemplo

Vamos ver o JavaTuples em ação. Aqui, veremos como iterar tuplas.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Cada tupla fornece métodos utilitários para verificar seus elementos de maneira semelhante à coleção.

  • contains(element) - verifica se o elemento está presente ou não.

  • containsAll(collection) - verifica se os elementos estão presentes ou não.

  • indexOf(element) - retorna o índice do primeiro elemento se presente, caso contrário -1.

  • lastIndexOf(element) - retorna o índice do último elemento se presente, caso contrário -1.

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

Exemplo

Vamos ver o JavaTuples em ação. Aqui, veremos como verificar os elementos em uma tupla.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

[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

Introdução

o org.javatuples.Unit classe representa uma tupla com um único elemento.

Declaração de classe

A seguir está a declaração para org.javatuples.Unit classe -

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

Construtores de classe

Sr. Não. Construtor e descrição
1

Unit(A value0)

Isso cria uma Tupla de Unidade.

Métodos de aula

Sr. Não. Método e Descrição
1

Pair add(Unit tuple)

Este método retorna uma tupla de par.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, add (tupla par) retorna Triplet e upto add (tupla Ennead) retorna tupla Decade.
2

Pair add(X0 value)

Este método adiciona um valor à tupla e retorna uma tupla de par.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, add (X0 valor0, X1 valor1) retorna Triplet e assim por diante até add () com nove parâmetros.
3

Pair addAt0(Unit value)

Este método adiciona uma tupla de unidade no índice 0 e retorna uma tupla de par.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, addAt0 (valor do par) retorna Triplet e assim por diante até addAt0 (Ennead). Outro método semelhante é addAt1 (valor da unidade) que adiciona uma unidade no índice0 e tem métodos semelhantes até addAt1 (Ennead).
4

Pair addAt0(X0 value)

Este método adiciona um valor no índice 0 e retorna uma tupla de par.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, addAt0 (X0 valor0, X1 valor1) retorna Triplet e assim por diante até addAt0 () com nove parâmetros. Outro método semelhante é addAt1 (valor X0) que adiciona um valor no índice0 e tem métodos semelhantes até addAt1 () com nove parâmetros.
5

static <X> Unit<X> fromArray(X[] array)

Crie a tupla da matriz.
6

static <X> Unit<X> fromCollection(Collection<X> collection)

Crie a tupla da coleção.
7

static <X> Unit<X> fromIterable(Iterable<X> iterable)

Crie uma tupla de iterável.
8

static <X> Unit<X> fromIterable(Iterable<X> iterable, int index)

Crie tupla a partir de iterável, começando com o índice especificado.
9

int getSize()

Retorna o tamanho da tupla.
10

A getValue0()

Retorne o valor da tupla.
11

<X> Unit<X> setAt0(X value)

Defina o valor da tupla.
12

static <A> Unit<A> with(A value0)

Crie a tupla usando o valor fornecido.

Métodos herdam

Esta classe herda métodos das seguintes classes -

  • org.javatuples.Tuple

  • Object

Exemplo

Vamos ver Unit Class em ação. Aqui, veremos como usar vários métodos.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Introdução

o org.javatuples.Pair classe representa uma tupla com dois elementos.

Declaração de Classe

A seguir está a declaração para org.javatuples.Pair classe -

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

Construtor de classe

Sr. Não. Construtor e descrição
1

Pair(A value0, B value1)

Isso cria uma tupla par.

Métodos de aula

Da mesma forma, setAt1 () define o valor no índice 1.

Sr. Não. Método e Descrição
1

Triplet add(Unit tuple)

Este método retorna uma tupla Triplet.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, add (tupla par) retorna Quarteto e upto add (tupla de octeto) retorna tupla decada.
2

Triplet add(X0 value)

Este método adiciona um valor à tupla e retorna uma tupla Triplet.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, add (X0 valor0, X1 valor1) retorna Quarteto e assim por diante até add () com oito parâmetros.
3

Triplet addAt0(Unit value)

Este método adiciona uma tupla de unidade no índice 0 e retorna uma tupla de tripleto.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, addAt0 (valor do par) retorna Quarteto e assim por diante até addAt0 (Octeto). Outro método semelhante é addAt1 (valor da unidade) que adiciona uma unidade no índice0 e tem métodos semelhantes até addAt2 (octeto).
4

Triplet addAt0(X0 value)

Este método adiciona um valor no índice 0 e retorna uma tupla Triplet.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, addAt0 (X0 valor0, X1 valor1) retorna Quarteto e assim por diante até addAt0 () com oito parâmetros. Outro método semelhante é addAt1 (valor X0) que adiciona um valor no index0 e tem métodos semelhantes até addAt2 () com oito parâmetros.
5

static <X> Pair<X,X> fromArray(X[] array)

Crie a tupla da matriz.
6

static <X> Pair<X,X> fromCollection(Collection<X> collection)

Crie a tupla da coleção.
7

static <X> Pair<X,X> fromIterable(Iterable<X> iterable)

Crie uma tupla de iterável.
8

static <X> Pair<X,X> fromIterable(Iterable<X> iterable, int index)

Crie tupla a partir de iterável, começando com o índice especificado.
9

int getSize()

Retorna o tamanho da tupla.
10

A getValue0()

Retorna o valor da tupla no índice 0.

Da mesma forma, getValue1 () retorna o valor no índice 1.
11

Unit<B> removeFrom0()

Retorne a tupla após remover o valor da tupla no índice 0.

Da mesma forma, removeFrom1 () retorna a tupla após remover o valor da tupla no índice 1.
12

<X> Pair<X,B> setAt0(X value)

Defina o valor da tupla no índice 0.
13

static <A,B> Pair<A,B> with(A value0, B value1)

Crie a tupla usando o valor fornecido.

Métodos herdam

Esta classe herda métodos das seguintes classes -

  • org.javatuples.Tuple

  • Object

Exemplo

Vamos ver a Pair Class em ação. Aqui, veremos como usar vários métodos.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Introdução

o org.javatuples.Triplet classe representa uma tupla com três elementos.

Declaração de Classe

A seguir está a declaração para org.javatuples.Triplet classe -

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

Construtores de classe

Sr. Não. Construtor e descrição
1

Triplet(A value0, B value1, C value2)

Isso cria uma tupla tripla.

Métodos de aula

Da mesma forma, setAt1 () upto setAt2 () define o valor no índice 1 e assim por diante.

Sr. Não. Método e Descrição
1

Quartet add(Unit tuple)

Este método retorna uma tupla de Quarteto.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, add (tupla par) retorna Quinteto e upto add (tupla septeto) retorna tupla decada.
2

Quartet add(X0 value)

Este método adiciona um valor à tupla e retorna uma tupla de Quarteto.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, add (X0 valor0, X1 valor1) retorna Quinteto e assim por diante até add () com sete parâmetros.
3

Quartet addAt0(Unit value)

Este método adiciona uma tupla de unidade no índice 0 e retorna uma tupla de Quarteto.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, addAt0 (valor do par) retorna Quinteto e assim por diante até addAt0 (Septeto). Outro método semelhante é addAt1 (valor da unidade) que adiciona uma unidade no índice0 e tem métodos semelhantes até addAt2 (septeto).
4

Quartet addAt0(X0 value)

Este método adiciona um valor no índice 0 e retorna uma tupla de Quarteto.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, addAt0 (X0 valor0, X1 valor1) retorna Quinteto e assim por diante até addAt0 () com sete parâmetros. Outro método semelhante é addAt1 (valor X0) que adiciona um valor no index0 e tem métodos semelhantes até addAt2 () com sete parâmetros.
5

static <X> Triplet<X,X,X> fromArray(X[] array)

Crie a tupla da matriz.
6

static <X> Triplet<X,X,X> fromCollection(Collection<X> collection)

Crie a tupla da coleção.
7

static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable)

Crie uma tupla de iterável.
8

static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable, int index)

Crie tupla a partir de iterável, começando com o índice especificado.
9

int getSize()

Retorna o tamanho da tupla.
10

A getValue0()

Retorna o valor da tupla no índice 0.

Da mesma forma, getValue1 () até getValue2 () retorna o valor no índice 1 e assim por diante.
11

Pair<B,C> removeFrom0()

Retorne a tupla após remover o valor da tupla no índice 0.

Da mesma forma, removeFrom1 () upto removeFrom2 () retorna a tupla após remover o valor da tupla no índice 1 e assim por diante.
12

<X> Triplet<X,B,C> setAt0(X value)

Defina o valor da tupla no índice 0.
13

static <A> Triplet<A,B,C> with(A value0, B value1, C value2)

Crie a tupla usando o valor fornecido.

Métodos herdam

Esta classe herda métodos das seguintes classes -

  • org.javatuples.Tuple

  • Object

Exemplo

Vamos ver a classe Triplet em ação. Aqui, veremos como usar vários métodos.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Introdução

o org.javatuples.Quartet classe representa uma tupla com quatro elementos.

Declaração de Classe

A seguir está a declaração para org.javatuples.Quartet classe -

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

Construtor de classe

Sr. Não. Construtor e descrição
1

Quartet(A value0, B value1, C value2, D value3)

Isso cria uma Tupla de Quarteto.

Métodos de aula

Da mesma forma, setAt1 () upto setAt3 () define o valor no índice 1 e assim por diante.

Sr. Não. Método e Descrição
1

Quintet add(Unit tuple)

Este método retorna uma tupla do Quinteto.

Similarmente, outros métodos para adicionar tuplas estão disponíveis, por exemplo, add (tupla par) retorna Sexteto e upto add (tupla Sexteto) retorna tupla decada.
2

Quintet add(X0 value)

Este método adiciona um valor à tupla e retorna uma tupla do quinteto.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, add (X0 valor0, X1 valor1) retorna Sexteto e assim por diante até add () com seis parâmetros.
3

Quintet addAt0(Unit value)

Este método adiciona uma tupla de unidade no índice 0 e retorna uma tupla de quinteto.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, addAt0 (valor do par) retorna Sexteto e assim por diante até addAt0 (Sexteto). Outro método semelhante é addAt1 (valor da unidade) que adiciona uma unidade no índice0 e tem métodos semelhantes até addAt2 (Sexteto).
4

Quintet addAt0(X0 value)

Este método adiciona um valor no índice 0 e retorna uma tupla de quinteto.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, addAt0 (X0 valor0, X1 valor1) retorna Sexteto e assim por diante até addAt0 () com seis parâmetros. Outro método semelhante é addAt1 (valor X0) que adiciona um valor no index0 e tem métodos semelhantes até addAt2 () com seis parâmetros.
5

static <X> Quartet<X,X,X,X> fromArray(X[] array)

Crie a tupla da matriz.
6

static <X> Quartet<X,X,X,X> fromCollection(Collection<X> collection)

Crie a tupla da coleção.
7

static <X> Quartet<X,X,X,X> fromIterable(Iterable<X> iterable)

Crie uma tupla de iterável.
8

static <X> Quartet<X,X,X,X> fromIterable(Iterable<X> iterable, int index)

Crie tupla a partir de iterável, começando com o índice especificado.
9

int getSize()

Retorna o tamanho da tupla.
10

A getValue0()

Retorna o valor da tupla no índice 0.

Da mesma forma, getValue1 () até getValue3 () retorna o valor no índice 1 e assim por diante.
11

Triplet<B,C,D> removeFrom0()

Retorne a tupla após remover o valor da tupla no índice 0.

Da mesma forma, removeFrom1 () upto removeFrom3 () retorna a tupla após remover o valor da tupla no índice 1 e assim por diante.
12

<X> Quartet<X,B,C,D> setAt0(X value)

Defina o valor da tupla no índice 0.
13

static <A> Quartet<A,B,C,D> with(A value0, B value1, C value2, D value3)

Crie a tupla usando o valor fornecido.

Métodos herdam

Esta classe herda métodos das seguintes classes -

  • org.javatuples.Tuple

  • Object

Exemplo

Vamos ver o Quartet Class em ação. Aqui, veremos como usar vários métodos.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

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

Introdução

o org.javatuples.Quintet classe representa uma tupla com cinco elementos.

Declaração de Classe

A seguir está a declaração para 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>

Construtor de classe

Sr. Não. Construtor e descrição
1

Quintet(A value0, B value1, C value2, D value3, E value4)

Isso cria uma tupla de quinteto.

Métodos de aula

Da mesma forma, setAt1 () upto setAt4 () define o valor no índice 1 e assim por diante.

Sr. Não. Método e Descrição
1

Sextet add(Unit tuple)

Este método retorna uma tupla Sextet.

Similarmente, outros métodos para adicionar tuplas estão disponíveis, por exemplo, add (tupla par) retorna Septeto e upto add (tupla quinteto) retorna tupla decada.
2

Sextet add(X0 value)

Este método adiciona um valor à tupla e retorna uma tupla Sexteto.

Da mesma forma, outros métodos para adicionar valores estão disponíveis, por exemplo, add (X0 valor0, X1 valor1) retorna Septeto e assim por diante até add () com cinco parâmetros.
3

Sextet addAt0(Unit value)

Este método adiciona uma tupla de unidade no índice 0 e retorna uma tupla de Sexteto.

Da mesma forma, outros métodos para adicionar tuplas estão disponíveis, por exemplo, addAt0 (valor do par) retorna Septeto e assim por diante até addAt0 (Quinteto). Outro método semelhante é addAt1 (valor da unidade) que adiciona uma unidade no índice0 e tem métodos semelhantes até addAt4 (Quinteto).
4

Sextet addAt0(X0 value)

Este método adiciona um valor no índice 0 e retorna uma tupla Sexteto.

Similarmente, outros métodos para adicionar valores estão disponíveis, por exemplo, addAt0 (X0 valor0, X1 valor1) retorna Septeto e assim por diante até addAt0 () com cinco parâmetros. Outro método semelhante é addAt1 (valor X0) que adiciona um valor no index0 e tem métodos semelhantes até addAt4 () com cinco parâmetros.
5

static <X> Quintet<X,X,X,X,X> fromArray(X[] array)

Crie a tupla da matriz.
6

static <X> Quintet<X,X,X,X,X> fromCollection(Collection<X> collection)

Crie a tupla da coleção.
7

static <X> Quintet<X,X,X,X,X> fromIterable(Iterable<X> iterable)

Crie uma tupla de iterável.
8

static <X> Quintet<X,X,X,X,X> fromIterable(Iterable<X> iterable, int index)

Crie tupla a partir de iterável, começando com o índice especificado.
9

int getSize()

Retorna o tamanho da tupla.
10

A getValue0()

Retorna o valor da tupla no índice 0.

Da mesma forma, getValue1 () até getValue4 () retorna o valor no índice 1 e assim por diante.
11

Quartet<B,C,D,E> removeFrom0()

Retorne a tupla após remover o valor da tupla no índice 0.

Da mesma forma, removeFrom1 () upto removeFrom4 () retorna a tupla após remover o valor da tupla no índice 1 e assim por diante.
12

<X> Quintet<X,B,C,D,E> setAt0(X value)

Defina o valor da tupla no índice 0.
13

static <A> Quintet<A,B,C,D,E> with(A value0, B value1, C value2, D value3, E value4)

Crie a tupla usando o valor fornecido.

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

[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]

Descrição do Problema

Como implementar a classe Decade usando a classe Ennead?

Exemplo

O exemplo a seguir mostra como realizar a tarefa acima. Cada tupla possui os métodos add () e addAtX () para converter a tupla.

Crie um arquivo de classe java chamado TupleTester em C:\>JavaTuples.

Arquivo: 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o TupleTester para ver o resultado -

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

Resultado

Verifique a saída

[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]
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved