JavaTuples 快速指南

---

---

JavaTuples - 概述

元组

元组是由一系列对象组成的序列，这些对象可以是相同类型，也可以是不同类型。请考虑以下示例：

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

以上对象是一个包含三个元素的元组：一个整数、一个字符串和一个连接对象。

JavaTuple

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

• Unit<A> - 1 个元素

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

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

• Quartet<A,B,C,D> - 4 个元素

• Quintet<A,B,C,D,E> - 5 个元素

• Sextet<A,B,C,D,E,F> - 6 个元素

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

• Octet<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 还为了语义目的提供了两个附加类。

• KeyValue<A,B>

• LabelValue<A,B>

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

• Iterable

• Serializable

• Comparable<Tuple>

• equals()

• hashCode()

• 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/ME 设置路径

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

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

为 Linux、UNIX、Solaris、FreeBSD 设置路径

环境变量 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 存档

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

设置 JavaTuples 环境

设置 **JavaTuples** 环境变量以指向 JavaTuples jar 文件存储在您机器上的基目录位置。假设我们将 javatuples-1.2.jar 解压到不同操作系统上的 JavaTuples 文件夹中，如下所示。

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

使用 Iterable

每个元组类都有一个 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]

JavaTuples - 类型转换

元组到列表/数组

元组可以转换为列表/数组，但代价是类型安全，转换后的列表类型为 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]

JavaTuples - 迭代

每个元组都实现 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 - Unit 类

简介

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

类声明

以下是 **org.javatuples.Unit** 类的声明：

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

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

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

在 **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 类表示包含两个元素的元组。

类声明

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

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

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

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

在 **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 - Triplet 类

简介

org.javatuples.Triplet 类表示包含三个元素的元组。

类声明

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

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

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 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 - Quartet 类

简介

org.javatuples.Quartet 类表示包含四个元素的元组。

类声明

以下是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

• Object

示例

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

在 **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 - Quintet 类

简介

org.javatuples.Quintet 类表示包含五个元素的元组。

类声明

以下是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

• Object

示例

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

在 **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 - Sextet 类

简介

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

• Object

示例

让我们看看 Sextet 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

在 **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 - Septet 类

简介

org.javatuples.Septet 类表示一个包含七个元素的元组。

类声明

以下是 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>

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 Septet 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

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

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

验证结果

使用 **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, 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]

JavaTuples - Octet 类

简介

org.javatuples.Octet 类表示一个包含八个元素的元组。

类声明

以下是 org.javatuples.Octet 类的声明：

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>

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 Octet 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

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

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

验证结果

使用 **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, 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]

JavaTuples - Ennead 类

简介

org.javatuples.Ennead 类表示一个包含九个元素的元组。

类声明

以下是 org.javatuples.Ennead 类的声明：

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>

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 Ennead 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

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

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

验证结果

使用 **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, 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]

JavaTuples - Decade 类

简介

org.javatuples.Decade 类表示一个包含十个元素的元组。

类声明

以下是 org.javatuples.Decade 类的声明：

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>

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 Ennead 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

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

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

验证结果

使用 **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, 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]

JavaTuples - LabelValues 类

简介

org.javatuples.LabelValue 类表示一个包含两个元素的元组，位置 0 和 1 分别重命名为“label”和“value”。

类声明

以下是 org.javatuples.LabelValue 类的声明：

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

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 LabelValue 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

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

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

验证结果

使用 **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
6
[1, 2]

JavaTuples - KeyValue 类

简介

org.javatuples.KeyValue 类表示一个包含两个元素的元组，位置 0 和 1 分别重命名为“key”和“value”。

类声明

以下是 org.javatuples.KeyValue 类的声明：

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

类构造函数

类方法

继承的方法

此类继承自以下类的方法：

• org.javatuples.Tuple

• Object

示例

让我们看看 KeyValue 类在实际应用中的情况。在这里，我们将了解如何使用各种方法。

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

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

验证结果

使用 **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
6
[1, 2]

使用 Unit 类实现 Pair

问题描述

如何使用 Unit 类实现 Pair 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, test]
[test, 5]

使用 Pair 类实现 Triplet

问题描述

如何使用 Pair 类实现 Triplet 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 6, test]
[test, 5, 6]

使用 Triplet 类实现 Quartet

问题描述

如何使用 Triplet 类实现 Quartet 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

在 **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<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);
   }
}

验证结果

使用 **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, 6, 7, test]
[test, 5, 6, 7]

使用 Quartet 类实现 Quintet

问题描述

如何使用 Quartet 类实现 Quintet 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 6, 7, 8, test]
[test, 5, 6, 7, 8]

使用 Quintet 类实现 Sextet

问题描述

如何使用 Quintet 类实现 Sextet 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 6, 7, 8, 9, test]
[test, 5, 6, 7, 8, 9]

使用 Sextet 类实现 Septet

问题描述

如何使用 Sextet 类实现 Septet 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 6, 7, 8, 9, 10, test]
[test, 5, 6, 7, 8, 9, 10]

使用 Septet 类实现 Octet

问题描述

如何使用 Septet 类实现 Octet 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 11]
[5, 6, 7, 8, 9, 10, 11, test]
[test, 5, 6, 7, 8, 9, 10, 11]

使用 Octet 类实现 Ennead

问题描述

如何使用 Octet 类实现 Ennead 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 11, 12]
[5, 6, 7, 8, 9, 10, 11, 12, test]
[test, 5, 6, 7, 8, 9, 10, 11, 12]

使用 Ennead 类实现 Decade

问题描述

如何使用 Ennead 类实现 Decade 类？

示例

以下示例演示了如何完成上述任务。每个元组都有 add() 和 addAtX() 方法来转换元组。

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

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

验证结果

使用 **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, 11, 12, 13]
[5, 6, 7, 8, 9, 10, 11, 12, 13, test]
[test, 5, 6, 7, 8, 9, 10, 11, 12, 13]