JavaTuples - 快速指南

---

JavaTuples - 概述

元组

元组是一系列对象，这些对象可能属于同一类型，也可能不同。考虑以下示例 -

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

上面的对象是一个由三个元素组成的元组：一个整数、一个字符串和一个连接对象。

Java元组

JavaTuples 是一个非常简单的库，它提供了十个不同的元组类，足以处理大多数与元组相关的需求。

• 单元<A> - 1 个元素

• 对<A,B> - 2 个元素

• 三元组<A,B,C> - 3 个元素

• 四重奏<A,B,C,D> - 4 个元素

• 五重奏<A,B,C,D,E> - 5 个元素

• 六重奏<A,B,C,D,E,F> - 6 个元素

• 七重奏 <A,B,C,D,E,F,G> - 7 个元素

• 八位字节<A,B,C,D,E,F,G,H> - 8 个元素

• Ennead<A,B,C,D,E,F,G,H,I> - 9 个元素

• Decade<A,B,C,D,E,F,G,H,I,J> - 10 个元素

除了这些元组类之外，出于语义考虑，JavaTuples 还提供了两个附加类。

• 键值<A,B>

• 标签值<A,B>

所有元组类都是类型安全且不可变的，并实现以下接口和方法。

• 可迭代

• 可串行化

• 可比较<元组>

• 等于（）

• 哈希码()

• toString()

元组与列表/数组

列表或数组可以包含任意数量的元素，但每个元素必须具有相同的类型，而元组只能包含特定数量的元素，可以具有不同类型的元素，但仍然是类型安全的。

JavaTuples - 环境设置

本地环境设置

如果您仍然愿意为 Java 编程语言设置环境，那么本节将指导您如何在计算机上下载和设置 Java。请按照以下步骤设置环境。

Java SE 可以通过下载 Java链接免费获得。因此，您可以根据您的操作系统下载一个版本。

按照说明下载 Java 并运行 .exe以在您的计算机上安装 Java。在计算机上安装 Java 后，您需要设置环境变量以指向正确的安装目录 -

设置 Windows 2000/XP 的路径

我们假设您已将 Java 安装在c:\Program Files\java\jdk目录中 -

• 右键单击“我的电脑”并选择“属性”。

• 单击“高级”选项卡下的“环境变量”按钮。

• 现在，更改“Path”变量，使其也包含 Java 可执行文件的路径。例如，如果路径当前设置为“C:\WINDOWS\SYSTEM32”，则将路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

设置 Windows 95/98/M 的路径

我们假设您已将 Java 安装在c:\Program Files\java\jdk目录中 -

• 编辑 'C:\autoexec.bat' 文件并在末尾添加以下行 - 'SET PATH=%PATH%;C:\Program Files\java\jdk\bin'

设置 Linux、UNIX、Solaris、FreeBS 的路径

应将环境变量 PATH 设置为指向 Java 二进制文件的安装位置。如果您在执行此操作时遇到问题，请参阅您的 shell 文档。

例如，如果您使用 bash 作为 shell，那么您可以将以下行添加到“.bashrc:export PATH=/path/to/java:$PATH”的末尾

流行的 Java 编辑器

要编写 Java 程序，您需要一个文本编辑器。市场上有许多复杂的 IDE。但现在，您可以考虑以下其中一项 -

• 记事本- 在 Windows 计算机上，您可以使用任何简单的文本编辑器，例如记事本（本教程推荐）、TextPad。

• Netbeans - 它是一个开源且免费的 Java IDE，可以从www.netbeans.org/index.html下载。

• Eclipse - 它也是由 eclipse 开源社区开发的 Java IDE，可以从www.eclipse.org下载。

下载 JavaTuples Archie

从Maven 存储库 - JavaTuples下载最新版本的 JavaTuples jar 文件。在本教程中，下载 javatuples-1.2.jar 并将其复制到 C:\> javatuples 文件夹中。

设置JavaTuples环境

将JavaTuples环境变量设置为指向计算机上存储 JavaTuples jar 的基本目录位置。假设我们已经在各种操作系统上的 JavaTuples 文件夹中提取了 javatuples-1.2.jar，如下所示。

设置 CLASSPATH 变量

将CLASSPATH环境变量设置为指向 JavaTuples jar 位置。假设您已将 javatuples-1.2.jar 存储在各种操作系统上的 JavaTuples 文件夹中，如下所示。

JavaTuples - 创建元组

可以使用多个选项创建使用 JavaTuple 类的元组。以下是示例 -

使用 with() 方法

每个元组类都有一个带有相应参数的 with() 方法。例如 -

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

使用构造函数

每个元组类都有一个带有相应参数的构造函数。例如 -

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

使用集合

每个元组类都有一个带有相应参数的 fromCollection() 方法。例如 -

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

使用可迭代

每个元组类都有一个 fromIterable() 方法来以通用方式获取元素。例如 -

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

例子

让我们看看 JavaTuples 的实际应用。在这里，我们将了解如何使用各种方式创建元组。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 获取值

元组具有 getValueX() 方法来获取值，而 getValue() 是一个通过索引获取值的通用方法。例如 Triplet 类具有以下方法。

• getValue(index) - 返回从 0 开始的索引处的值。

• getValue0() - 返回索引 0 处的值。

• getValue1() - 返回索引 1 处的值。

• getValue2() - 返回索引 2 处的值。

特征

• getValueX() 方法是类型安全的，不需要强制转换，但 getValue(index) 是通用的。

• 元组具有最多元素计数的 getValueX() 方法。例如，Triplet 没有 getValue3() 方法，但 Quartet 有。

• 语义类 KeyValue 和 LabelValue 有 getKey()/getValue() 和 getLabel()/getValue() 而不是 getValue0()/getValue1() 方法。

例子

让我们看看 JavaTuples 的实际应用。在这里，我们将了解如何使用各种方式从元组中获取值。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

Test
5
Test
5
Test
5

JavaTuples - 设置值

元组具有 setAtX() 方法来设置特定索引处的值。例如 Triplet 类具有以下方法。

• setAt0() - 在索引 0 处设置值。

• setAt1() - 在索引 1 处设置值。

• setAt2() - 在索引 2 处设置值。

特征

• 元组是不可变的。每个 setAtX() 返回一个新元组，用于查看更新后的值。

• 可以使用 setAtX() 方法更改元组位置的类型。

例子

让我们看看 JavaTuples 的实际应用。在这里，我们将了解如何使用各种方式在元组中设置值。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 添加元素

元组在其末尾有 add() 方法，它也会更改元组的类型。例如，向 Triplet 元组添加一个元素会将其转换为 Quartet 元组。

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

元组还具有 addAtX() 方法，用于在从 0 开始的特定索引处添加位置。

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

元组可以使用 addAtX() 方法添加多个元素。

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

元组也可以使用 addAtX() 方法添加元组。

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

例子

让我们看看 JavaTuples 的实际应用。在这里，我们将了解如何使用各种方式在元组中添加值。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);     
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 删除元素

元组具有removeAtX()方法来删除特定索引处的值。例如 Triplet 类具有以下方法。

• removeAt0() - 删除索引 0 处的值并返回结果元组。

• removeAt1() - 删除索引 1 处的值并返回结果元组。

• removeAt2() - 删除索引 2 处的值并返回结果元组。

删除一个元素会返回一个新的元组。

例子

让我们看看 JavaTuples 的实际应用。在这里我们将看到如何删除元组中的值。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);  
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

Java元组 - 转换

元组到列表/数组

元组可以转换为列表/数组，但以类型安全为代价，转换后的列表是 List<Object>/Object[] 类型。

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

集合/数组到元组

集合可以使用 fromCollection() 方法转换为元组，数组可以使用 fromArray() 方法转换为元组。

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

如果数组/集合的大小与元组的大小不同，则会发生 IllegalArgumentException。

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

例子

让我们看看 JavaTuples 的实际应用。在这里，我们将了解如何将元组转换为列表/数组，反之亦然。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);      
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

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

Java元组 - 迭代

每个元组都实现 Iterable 接口，并且可以以与集合类似的方式进行迭代。

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

例子

让我们看看 JavaTuples 的实际应用。在这里我们将看到如何迭代元组。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 检查元素

每个元组都提供实用方法来以与集合类似的方式检查其元素。

• contains(element) - 检查元素是否存在。

• containsAll(collection) - 检查元素是否存在。

• indexOf(element) - 返回第一个元素的索引（如果存在），否则返回-1。

• lastIndexOf(element) - 返回最后一个元素的索引（如果存在），否则返回 -1。

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

例子

让我们看看 JavaTuples 的实际应用。在这里我们将了解如何检查元组中的元素。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

[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

JavaTuples - 单元类

介绍

org.javatuples.Unit类表示具有单个元素的元组。

类声明

以下是org.javatuples.Unit类的声明-

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

类构造函数

类方法

方法继承

该类继承了以下类的方法 -

• org.javatuples.Tuple

• 目的

例子

让我们看看单元类的实际应用。在这里我们将看到如何使用各种方法。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - Pair 类

介绍

org.javatuples.Pair类表示具有两个元素的Tuple。

类别声明

以下是org.javatuples.Pair类的声明-

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

类构造函数

类方法

方法继承

该类继承了以下类的方法 -

• org.javatuples.Tuple

• 目的

例子

让我们看看 Pair Class 的实际应用。在这里我们将看到如何使用各种方法。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 三元组类

介绍

org.javatuples.Triplet类表示具有三个元素的Tuple。

类别声明

以下是org.javatuples.Triplet类的声明-

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

类构造函数

类方法

方法继承

该类继承了以下类的方法 -

• org.javatuples.Tuple

• 目的

例子

让我们看看 Triplet 类的实际应用。在这里我们将看到如何使用各种方法。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 四重奏类

介绍

org.javatuples.Quartet类表示具有四个元素的Tuple。

类别声明

以下是org.javatuples.Quartet类的声明-

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

类构造函数

类方法

方法继承

该类继承了以下类的方法 -

• org.javatuples.Tuple

• 目的

例子

让我们看看四重奏班的实际行动。在这里我们将看到如何使用各种方法。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 五重奏类

介绍

org.javatuples.Quintet类表示具有五个元素的Tuple。

类别声明

以下是org.javatuples.Quintet类的声明-

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

类构造函数

类方法

方法继承

该类继承了以下类的方法 -

• org.javatuples.Tuple

• 目的

例子

让我们看看五重奏班的实际情况。在这里我们将看到如何使用各种方法。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 六重奏类

介绍

org.javatuples.Sextet类表示具有六个元素的元组。

类别声明

以下是org.javatuples.Sextet类的声明-

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>

类构造函数

类方法

方法继承

该类继承了以下类的方法 -

• org.javatuples.Tuple

• 目的

例子

让我们看看六重奏班的实际情况。在这里我们将看到如何使用各种方法。

在C:\>JavaTuples中创建一个名为 TupleTester 的 java 类文件。

文件：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);
   }
}

验证结果

使用javac编译器编译类，如下所示 -

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

现在运行 TupleTester 查看结果 -

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

输出

验证输出

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

JavaTuples - 七重奏类

介绍

org.javatuples.Septet类表示具有七个元素的Tuple。

类别声明

以下是org.javatuples.Septet类的声明-

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>

类构造函数

类方法