Javatuples 简明教程

JavaTuples - Quick Guide

JavaTuples - Overview

Tuple

元组是对象序列，这些对象可能相同类型，也可能不同类型。请考虑以下示例 −

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

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

JavaTuple

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

  1. Unit<A> - 1 element

  2. Pair<A,B> - 2 elements

  3. Triplet<A,B,C> - 3 elements

  4. Quartet<A,B,C,D> - 4 elements

  5. Quintet<A,B,C,D,E> - 5 elements

  6. Sextet<A,B,C,D,E,F> - 6 elements

  7. Septet<A,B,C,D,E,F,G> - 7 elements

  8. Octet<A,B,C,D,E,F,G,H> - 8 elements

  9. Ennead<A,B,C,D,E,F,G,H,I> - 9 elements

  10. Decade<A,B,C,D,E,F,G,H,I,J> - 10 elements

除了这些元组类之外，JavaTuples 还出于语义原因提供了另外两个类。

  1. KeyValue<A,B>

  2. LabelValue<A,B>

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

  1. Iterable

  2. Serializable

  3. Comparable<Tuple>

  4. equals()

  5. hashCode()

  6. toString()

Tuple vs List/Array

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

JavaTuples - Environment Setup

Local Environment Setup

如果您仍然愿意为 Java 编程语言设置您的环境，则本节指导您如何在您的机器上下载并设置 Java。请按照下面提到的步骤设置环境。

Java SE 可以从链接 Download Java 中免费获取。因此，您可以根据自己的操作系统下载版本。

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

Setting up the Path for Windows 2000/XP

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

  1. 右键单击“我的电脑”，然后选择“属性”。

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

  3. 现在，更改“路径”变量，使其也包含指向 Java 可执行文件的路径。例如，如果路径目前设置为“C:\WINDOWS\SYSTEM32”，那么将您的路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

Setting up the Path for Windows 95/98/M

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

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

Setting up the Path for Linux, UNIX, Solaris, FreeBS

环境变量 PATH 应设置为指向已安装 Java 二进制文件的位置。如果你在这方面遇到问题，请参阅 shell 文档。

例如，如果您用 bash 作为您的 shell，则您将向您 '.bashrc: export PATH=/path/to/java:$PATH' 的末尾添加以下行

Popular Java Editor

要编写 Java 程序，您需要一个文本编辑器。市场中有许多高级集成开发环境可用。但目前，您可以考虑以下选项之一 −

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

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

  3. Eclipse − 它也是一个由 eclipse 开源社区开发的 Java 集成开发环境，可以从 www.eclipse.org 下载。

Download JavaTuples Archie

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

OS

Archive name

Windows

javatuples-1.2.jar

Linux

javatuples-1.2.jar

Mac

javatuples-1.2.jar

Set JavaTuples Environment

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

OS

Output

Windows

将环境变量 JavaTuples 设置为 C:\JavaTuples

Linux

export JavaTuples=/usr/local/JavaTuples

Mac

export JavaTuples=/Library/JavaTuples

Set CLASSPATH Variable

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

OS

Output

Windows

将环境变量 CLASSPATH 设置为 %CLASSPATH%;%JavaTuples%\javatuples-1.2.jar;.;

Linux

export CLASSPATH=$CLASSPATH:$JavaTuples/javatuples-1.2.jar:.

Mac

export CLASSPATH=$CLASSPATH:$JavaTuples/javatuples-1.2.jar:.

JavaTuples - Create Tuples

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

Using with() Methods

每个元组类都有一个带对应参数的 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));

Using Constructor

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

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

Using Collections

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

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

Using Iterable

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

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

Example

让我们来看看 JavaTuples 在操作中的表现。此处我们将了解使用各种方式创建元组。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Get Values

元组具有 getValueX() 方法来获取值，以及 getValue() 方法来通过索引获取值。例如，Triplet 类具有以下方法。

  1. getValue(index) − 从 0 开始返回索引处的值。

  2. getValue0() − 返回索引为 0 处的值。

  3. getValue1() − 返回索引为 1 处的值。

  4. getValue2() − 返回索引为 2 处的值。

Feature

  1. getValueX() 方法是类型安全的，且不需要转换，但 getValue(index) 是泛型的。

  2. 元组具有多达元素数量的 getValueX() 方法。例如，Triplet 没有 getValue3() 方法，但 Quartet 有。

  3. 语义类 KeyValue 和 LabelValue 具有 getKey()/getValue() 以及 getLabel()/getValue()，而不是 getValue0()/getValue1() 方法。

Example

让我们实际看看 JavaTuples。我们将了解如何使用各种方法从元组获取值。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

Test
5
Test
5
Test
5

JavaTuples - Set Values

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

  1. setAt0() − 设置索引为 0 处的值。

  2. setAt1() − 设置索引为 1 处的值。

  3. setAt2() − 设置索引为 2 处的值。

Feature

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

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

Example

让我们实际看看 JavaTuples。我们将了解如何使用各种方法在元组中设置值。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Add Elements

元组在元组的末尾具有 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);

Example

让我们来看看 JavaTuples 的实际应用。这里我们将看到如何使用各种方法在元组中添加值。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Remove Elements

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

  1. removeAt0() − 移除索引 0 处的值，并返回结果元组。

  2. removeAt1() − 移除索引 1 处的值，并返回结果元组。

  3. removeAt2() − 移除索引 2 处的值，并返回结果元组。

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

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Conversion

Tuple to List/Array

元组可以转换成 List/Array，但会损失类型安全性，转换后的列表是 List<Object>/Object[] 类型。

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

Collection/Array to Tuple

集合可以使用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 ...

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

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

JavaTuples - Iteration

每个元组都实现了 Iterable 接口，可以像集合一样迭代。

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

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Checking Elements

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

  1. contains(element) − 检查元素是否存在。

  2. containsAll(collection) − 检查元素组是否存在。

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

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

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

Example

我们来看一下 JavaTuples 的实际应用。我们将会看到如何检查元组中的元素。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Unit Class

Introduction

org.javatuples.Unit 类表示一个包含单个元素的元组。

Class declaration

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

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

Class constructors

Sr.No.

Constructor & Description

1

Unit(A value0) 这将创建一个 Unit 元组。

Class Methods

Sr.No.

Method & Description

1

Pair add(Unit tuple) 此方法返回一个 Pair 元组。类似地，还有其他方法可以添加元组，例如，add(Pair tuple) 返回 Triplet，upto add(Ennead tuple) 返回 Decade 元组。

2

Pair add(X0 value) 此方法向元组中添加一个值并返回一个 Pair 元组。类似地，还有其他方法可以添加值，例如，add(X0 value0, X1 value1) 返回 Triplet，依此类推，upto add() พร้อม九个参数。

3

Pair addAt0(Unit value) 此方法在索引 0 处添加一个 Unit 元组并返回一个 Pair 元组。类似地，还有其他方法可以添加元组，例如，addAt0(Pair value) 返回 Triplet，依此类推，upto addAt0(Ennead)。另一种类似的方法是 addAt1(Unit value)，它在索引 0 处添加一个单元，并具有类似的方法 upto addAt1(Ennead)。

4

Pair addAt0(X0 value) 此方法在索引 0 处添加一个值并返回一个 Pair 元组。类似地，还有其他方法可以添加值，例如，addAt0(X0 value0, X1 value1) 返回 Triplet，依此类推，upto addAt0() พร้อม九个参数。另一种类似的方法是 addAt1(X0 value)，它在索引 0 处添加一个值，并具有类似的方法 upto addAt1() 以及九个参数。

5

static &lt;X&gt; Unit&lt;X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Unit&lt;X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Unit&lt;X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Unit&lt;X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回元组的值。

11

&lt;X&gt; Unit&lt;X&gt; setAt0(X value) 设置元组的值。

12

static &lt;A&gt; Unit&lt;A&gt; with(A value0) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

我们来看一下 Unit 类的实际应用。我们将会看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Pair Class

Introduction

org.javatuples.Pair 类表示一个包含两个元素的元组。

Class Declaration

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

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

Class Constructor

Sr.No.

Constructor & Description

1

Pair(A value0, B value1) 这将创建一个 Pair 元组。

Class Methods

Sr.No.

Method & Description

1

Triplet add(Unit tuple) 此方法返回元组 Triplet。类似的，还提供了其他方法来添加元组，例如 add(Pair tuple) 返回 Quartet，而 add(Octet tuple) 返回 Decade 元组。

2

Triplet add(X0 value) 此方法向元组添加一个值并返回元组 Triplet。类似地，还提供了其他方法来添加值，例如 add(X0 value0, X1 value1) 返回 Quartet，依此类推，最多 add() 带有八个参数。

3

Triplet addAt0(Unit value) 此方法在索引 0 处添加元组 Unit 并返回元组 Triplet。类似的，还提供了其他方法来添加元组，例如 addAt0(Pair value) 返回 Quartet，依此类推，最多到 addAt0(Octet)。其他类似的方法有 addAt1(Unit value)，它在索引 0 处添加一个单位，并有类似的方法，最多到 addAt2(Octet)。

4

Triplet addAt0(X0 value) 此方法在索引 0 处添加一个值并返回元组 Triplet。类似的，还提供了其他方法来添加值，例如 addAt0(X0 value0, X1 value1) 返回 Quartet，依此类推，最多 addAt0() 带有八个参数。其他类似的方法有 addAt1(X0 value)，它在索引 0 处添加一个值，并有类似的方法，最多到 addAt2() 带有八个参数。

5

static &lt;X&gt; Pair&lt;X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Pair&lt;X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Pair&lt;X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Pair&lt;X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处元组的值。类似地，getValue1() 返回索引 1 处的值。

11

Unit&lt;B&gt; removeFrom0() 在移除索引 0 处元组值后返回元组。类似地，removeFrom1() 返回在移除索引 1 处元组值后的元组。

12

&lt;X&gt; Pair&lt;X,B&gt; setAt0(X value) 设置索引 0 处元组的值。

13

static &lt;A,B&gt; Pair&lt;A,B&gt; with(A value0, B value1) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 Pair 类在实际中的使用。在此，我们将了解如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Triplet Class

Introduction

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

Class Declaration

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

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

Class Constructors

Sr.No.

Constructor & Description

1

Triplet(A value0, B value1, C value2) 这样会创建一个 Triplet 元组。

Class Methods

Sr.No.

Method & Description

1

Quartet add(Unit tuple) 此方法返回元组 Quartet。类似的，还提供了其他方法来添加元组，例如 add(Pair tuple) 返回 Quintet，而 add(Septet tuple) 返回 Decade 元组。

2

Quartet add(X0 value) 此方法向元组添加一个值并返回元组 Quartet。类似的，还提供了其他方法来添加值，例如 add(X0 value0, X1 value1) 返回 Quintet，依此类推，最多 add() 带有七个参数。

3

Quartet addAt0(Unit value) 此方法在索引 0 处添加元组 Unit 并返回元组 Quartet。类似的，还提供了其他方法来添加元组，例如 addAt0(Pair value) 返回 Quintet，依此类推，最多到 addAt0(Septet)。其他类似的方法有 addAt1(Unit value)，它在索引 0 处添加一个单位，并有类似的方法，最多到 addAt2(Septet)。

4

Quartet addAt0(X0 value) 此方法在索引 0 处添加一个值并返回 Quartet 元组。类似地，还可以使用其他方法添加值，例如 addAt0(X0 value0, X1 value1) 返回 Quintet，依此类推，直至 addAt0()，共有七个参数。其他类似的方法有 addAt1(X0 value)，它在索引 0 处添加一个值，并带有类似的方法，直到 addAt2()，共有七个参数。

5

static &lt;X&gt; Triplet&lt;X,X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Triplet&lt;X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Triplet&lt;X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Triplet&lt;X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 在索引 0 处返回元组的值。类似地，getValue1() 至 getValue2() 在索引 1 处返回该值，依此类推。

11

Pair&lt;B,C&gt; removeFrom0() 在索引 0 处从元组中移除值后，返回元组。类似地，removeFrom1() 至 removeFrom2() 在索引 1 处从元组中移除值后返回元组，依此类推。

12

&lt;X&gt; Triplet&lt;X,B,C&gt; setAt0(X value) 在索引 0 处设置元组的值。

13

static &lt;A&gt; Triplet&lt;A,B,C&gt; with(A value0, B value1, C value2) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 Triplet 类的实际应用。我们将在其中了解如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Quartet Class

Introduction

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

Class Declaration

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

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

Class Constructor

Sr.No.

Constructor & Description

1

Quartet(A value0, B value1, C value2, D value3) 这将创建一个 Quartet 元组。

Class Methods

Sr.No.

Method & Description

1

Quintet add(Unit tuple) 此方法返回一个 Quintet 元组。类似地，还有其他方法可用于添加元组，例如 add(Pair tuple) 返回 Sextet，直至 add(Sextet tuple) 返回 Decade 元组。

2

Quintet add(X0 value) 此方法向元组中添加一个值并返回一个 Quintet 元组。类似地，还有其他方法可用于添加值，例如 add(X0 value0, X1 value1) 返回 Sextet，直至 add()，共有六个参数。

3

Quintet addAt0(Unit value) 此方法在索引 0 处添加一个 Unit 元组并返回一个 Quintet 元组。类似地，还有其他方法可用于添加元组，例如 addAt0(Pair value) 返回 Sextet，直到 addAt0(Sextet)。其他类似的方法有 addAt1(Unit value)，它在索引 0 处添加一个单位，并带有类似的方法，直到 addAt2(Sextet)。

4

Quintet addAt0(X0 value) 此方法在索引 0 处添加一个值并返回一个 Quintet 元组。类似地，还有其他方法可用于添加值，例如 addAt0(X0 value0, X1 value1) 返回 Sextet，依此类推，直至 addAt0()，共有六个参数。其他类似的方法有 addAt1(X0 value)，它在索引 0 处添加一个值，并带有类似的方法，直到 addAt2()，共有六个参数。

5

static &lt;X&gt; Quartet&lt;X,X,X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Quartet&lt;X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Quartet&lt;X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代中创建元组。

8

static &lt;X&gt; Quartet&lt;X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代中创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处的元组值。类似地，从 getValue1() 到 getValue3() 会返回索引 1 处的值，依此类推。

11

Triplet&lt;B,C,D&gt; removeFrom0() 返回移除索引 0 处元组值后的元组。类似地，从 removeFrom1() 到 removeFrom3() 会返回移除索引 1 处元组值后的元组，依此类推。

12

&lt;X&gt; Quartet&lt;X,B,C,D&gt; setAt0(X value) 设置索引 0 处的元组值。

13

static &lt;A&gt; Quartet&lt;A,B,C,D&gt; with(A value0, B value1, C value2, D value3) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - Quintet Class

Introduction

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

Class Declaration

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

Class Constructor

Sr.No.

Constructor & Description

1

Quintet(A value0, B value1, C value2, D value3, E value4) 这将创建 Quintet 元组。

Class Methods

Sr.No.

Method & Description

1

Sextet add(Unit tuple) 此方法返回 Sextet 元组。类似地，可以使用其他方法添加元组，例如 add(Pair tuple) 返回 Septet，最多 add(Quintet tuple) 返回 Decade 元组。

2

Sextet add(X0 value) 此方法向元组添加一个值并返回 Sextet 元组。类似地，可以使用其他方法添加值，例如 add(X0 value0, X1 value1) 返回 Septet，最多通过五参数调用 add()。

3

Sextet addAt0(Unit value) 此方法在索引 0 处添加 Unit 元组并返回 Sextet 元组。类似地，可以使用其他方法添加元组，例如 addAt0(Pair value) 返回 Septet，最多 addAt0(Quintet)。其他类似方法是 addAt1(Unit value)，它在索引 0 处添加一个单元，并且具有类似方法最多到 addAt4(Quintet)。

4

Sextet addAt0(X0 value) 此方法在索引 0 处添加一个值并返回 Sextet 元组。类似地，可以使用其他方法添加值，例如 addAt0(X0 value0, X1 value1) 返回 Septet，最多通过五参数调用 addAt0()。其他类似方法是 addAt1(X0 value)，它在索引 0 处添加一个值，并且具有类似方法最多到通过五参数调用 addAt4()。

5

static &lt;X&gt; Quintet&lt;X,X,X,X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Quintet&lt;X,X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Quintet&lt;X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代中创建元组。

8

static &lt;X&gt; Quintet&lt;X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代中创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处的元组值。类似地，从 getValue1() 到 getValue4() 会返回索引 1 处的值，依此类推。

11

Quartet&lt;B,C,D,E&gt; removeFrom0() 在从索引 0 处移除元组值后返回元组。类似地，removeFrom1() 到 removeFrom4() 在从索引 1 处移除元组值后返回元组，依此类推。

12

&lt;X&gt; Quintet&lt;X,B,C,D,E&gt; setAt0(X value) 设置索引 0 处的元组值。

13

static &lt;A&gt; Quintet&lt;A,B,C,D,E&gt; with(A value0, B value1, C value2, D value3, E value4) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

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]

JavaTuples - Sextet Class

Introduction

org.javatuples.Sextet 类表示一个包含 6 个元素的元组。

Class Declaration

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

Class Constructor

Sr.No.

Constructor & Description

1

Sextet(A value0, B value1, C value2, D value3, E value4, F value5) 这将创建一个元组 Sextet。

Class Methods

Sr.No.

Method & Description

1

Septet add(Unit tuple) 此方法返回一个元组 Septet。类似地，还提供了其他添加元组的方法，例如 add(Pair tuple) 返回 Octet，而 upto add(Quartet tuple) 返回 Decade 元组。

2

Septet add(X0 value) 此方法向元组中添加一个值并返回一个元组 Septet。类似地，还提供了其他添加值的方法，例如 add(X0 value0, X1 value1) 返回 Octet，依此类推，upto add() 带有四个参数。

3

Septet addAt0(Unit value) 此方法在索引 0 处添加一个 Unit 元组并返回一个元组 Septet。类似地，还提供了其他添加元组的方法，例如 addAt0(Pair value) 返回 Octet，依此类推，upto addAt0(Quartet)。其他类似的方法有 addAt1(Unit value)，它在索引 0 处添加一个单位，并有类似的方法 upto addAt5(Quartet)。

4

Septet addAt0(X0 value) 此方法在索引 0 处添加一个值并返回一个元组 Septet。类似地，还提供了其他添加值的方法，例如 addAt0(X0 value0, X1 value1) 返回 Octet，依此类推，upto addAt0() 带有四个参数。其他类似的方法有 addAt1(X0 value)，它在索引 0 处添加一个值，并有类似的方法 upto addAt5() 带有四个参数。

5

static &lt;X&gt; Sextet&lt;X,X,X,X,X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Sextet&lt;X,X,X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Sextet&lt;X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Sextet&lt;X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处的元组值。类似地，getValue1() 到 getValue5() 返回索引 1 及更高索引处的值。

11

Quintet&lt;B,C,D,E,F&gt; removeFrom0() 返回在索引 0 处移除元组值后的元组。类似地，removeFrom1() 到 removeFrom5() 返回在索引 1 及更高索引处移除元组值后的元组。

12

&lt;X&gt; Sextet&lt;X,B,C,D,E,F&gt; setAt0(X value) 设置索引 0 处的元组的值。

13

static &lt;A&gt; Sextet&lt;A,B,C,D,E,F&gt; with(A value0, B value1, C value2, D value3, E value4, F value5) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看元组类正在行动。这里我们将看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

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]

JavaTuples - Septet Class

Introduction

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

Class Declaration

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

Class Constructor

Sr.No.

Constructor & Description

1

Septet(A value0, B value1, C value2, D value3, E value4, F value5, G value6) 这将创建一个 Septet 元组。

Class Methods

Sr.No.

Method & Description

1

Octet add(Unit tuple) 此方法返回一个 Octet 元组。类似地，还有其他可用的添加元组的方法，例如 add(Pair tuple) 返回 Ennead，而 upto add(Triplet tuple) 返回 Decade 元组。

2

Octet add(X0 value) 此方法向元组中添加一个值并返回一个 Octet 元组。类似地，还有其他可用的添加值的方法，例如 add(X0 value0, X1 value1) 返回 Ennead，依此类推，最多可带三个参数的 add()。

3

Octet addAt0(Unit value) 此方法在索引 0 处添加一个 Unit 元组并返回一个 Octet 元组。类似地，还有其他可用的添加元组的方法，例如 addAt0(Pair value) 返回 Ennead，依此类推，最多可到 addAt0(Triplet)。其他类似的方法有 addAt1(Unit value)，可在索引 0 处添加一个单元，并具有类似的方法，最多可到带有三个参数的 addAt6(Triplet)。

4

Octet addAt0(X0 value) 此方法在索引 0 处添加一个值并返回一个 Octet 元组。类似地，还有其他可用的添加值的方法，例如 addAt0(X0 value0, X1 value1) 返回 Ennead，依此类推，最多可带三个参数的 addAt0()。其他类似的方法有 addAt1(X0 value)，可在索引 0 处添加一个值，并具有类似的方法，最多可到带有三个参数的 addAt6()。

5

static &lt;X&gt; Septet&lt;X,X,X,X,X,X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Septet&lt;X,X,X,X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Septet&lt;X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Septet&lt;X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处的元组值。类似地，getValue1() 到 getValue6() 返回索引 1 处的值，依此类推。

11

Sextet&lt;B,C,D,E,F,G&gt; removeFrom0() 在从索引 0 处移除元组值后返回元组。类似地，removeFrom1() 到 removeFrom6() 在从索引 1 处移除元组值后返回元组，依此类推。

12

&lt;X&gt; Septet&lt;X,B,C,D,E,F,G&gt; setAt0(X value) 设置索引 0 处的元组值。

13

static &lt;A&gt; Septet&lt;A,B,C,D,E,F,G&gt; with(A value0, B value1, C value2, D value3, E value4, F value5, G value6) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 Septet 类如何运作。在此，我们将看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

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]

JavaTuples - Octet Class

Introduction

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

Class Declaration

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

Class Constructor

Sr.No.

Constructor & Description

1

Octet(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7) 这意味着创建了一个八重元组。

Class Methods

Sr.No.

Method & Description

1

Ennead add(Unit tuple) 此方法返回一个元九元组。同样还有可用于添加元组的其他方法，例如 add(Pair tuple) 返回十元组。

2

Ennead add(X0 value) 此方法向元组添加一个值，并返回一个元九元组。同样还有可用于添加值的元组，例如 add(X0 value0, X1 value1) 返回十元组。

3

Ennead addAt0(Unit value) 此方法在索引 0 处添加一个单位元组，并返回一个元九元组。同样还有可用于添加元组的其他方法，例如 addAt0(Pair value) 返回十元组。还有其他类似的方法，例如 addAt1(Unit value) 在索引 0 处添加一个单位，并且有类似的方法一直到 addAt7(Pair)。

4

Ennead addAt0(X0 value) 此方法在索引 0 处添加一个值，并返回一个元九元组。同样还有可用于添加值的元组，例如 addAt0(X0 value0, X1 value1) 返回十元组。还有其他类似的方法，例如 addAt1(X0 value) 在索引 0 处添加一个值，并且有类似的方法一直到 addAt7()（带两个参数）。

5

static &lt;X&gt; Octet&lt;X,X,X,X,X,X,X,X&gt; fromArray(X[] array) 从数组创建元组。

6

static &lt;X&gt; Octet&lt;X,X,X,X,X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Octet&lt;X,X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Octet&lt;X,X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始创建。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处元组的值。同样，getValue1() 到 getValue7() 会返回索引 1 处的值，以此类推。

11

Septet&lt;B,C,D,E,F,G,H&gt; removeFrom0() 返回从索引 0 处移除元组值后的元组。同样，removeFrom1() 到 removeFrom7() 会返回从索引 1 处移除元组值后的元组，以此类推。

12

&lt;X&gt; Octet&lt;X,B,C,D,E,F,G,H&gt; setAt0(X value) 设置索引 0 处元组的值。

13

static &lt;A&gt; Octet&lt;A,B,C,D,E,F,G,H&gt; with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 Octet 类如何运作。在此，我们将看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

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]

JavaTuples - Ennead Class

Introduction

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

Class Declaration

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

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) 这会创建一个九元组。

Class Methods

Sr.No.

Method & Description

1

Decade add(Unit tuple) 此方法返回一个十元组。

2

Decade add(X0 value) 此方法会向元组添加一个值并返回一个十元组。

3

Decade addAt0(Unit value) 此方法在索引 0 处添加一个单位元组并返回一个十元组。其他类似的方法是 addAt1(Unit value)，它在索引 0 处添加一个单元，还有类似的方法，直到 addAt8(Unit)。

4

Decade addAt0(X0 value) 此方法在索引 0 处添加一个值并返回一个十元组。其他类似的方法是 addAt1(X0 value)，它在索引 0 处添加一个值，还有类似的方法，直到 addAt8()（带有一个参数）。

5

static &lt;X&gt; Ennead&lt;X,X,X,X,X,X,X,X,X &gt; fromArray(X[] array) 从阵列创建元组。

6

static &lt;X&gt; Ennead&lt;X,X,X,X,X,X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

7

static &lt;X&gt; Ennead&lt;X,X,X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

8

static &lt;X&gt; Ennead&lt;X,X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定的索引开始。

9

int getSize() 返回元组的大小。

10

A getValue0() 返回索引 0 处的元组值。类似地，getValue1() 直到 getValue8() 返回索引 1 处的值，依此类推。

11

Octet&lt;B,C,D,E,F,G,H,I&gt; removeFrom0() 返回在索引 0 处删除元组值后的元组。类似地，removeFrom1() 直到 removeFrom8() 返回在索引 1 处删除元组值后的元组，依此类推。

12

&lt;X&gt; Ennead&lt;X,B,C,D,E,F,G,H,I&gt; setAt0(X value) 设置索引 0 处的元组值。

13

static &lt;A&gt; Ennead&lt;A,B,C,D,E,F,G,H,I&gt; with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 Ennead 类的作用。我们将在其中看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

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]

JavaTuples - Decade Class

Introduction

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

Class Declaration

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

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 ) 这会创建一个十元组。

Class Methods

Sr.No.

Method & Description

1

static &lt;X&gt; Decade&lt;X,X,X,X,X,X,X,X,X,X &gt; fromArray(X[] array) 从阵列创建元组。

2

static &lt;X&gt; Decade&lt;X,X,X,X,X,X,X,X,X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

3

static &lt;X&gt; Decade&lt;X,X,X,X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

4

static &lt;X&gt; Decade&lt;X,X,X,X,X,X,X,X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从指定索引开始创建元组。

5

int getSize() 返回元组的大小。

6

A getValue0() 返回元组的索引 0 的值。类似地，getValue1() 直到 getValue9() 返回索引 1 及后面的值。

7

Ennead&lt;B,C,D,E,F,G,H,I,J&gt; removeFrom0() 从索引 0 处删除元组的值后返回元组。类似地，removeFrom1() 直到 removeFrom9() 返回从索引 1 及后面的值处删除元组的值后的元组。

8

&lt;X&gt; Decade&lt;X,B,C,D,E,F,G,H,I,J&gt; setAt0(X value) 设置元组的索引 0 的值。

9

static &lt;A&gt; Decade&lt;A,B,C,D,E,F,G,H,I,J&gt; with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8, I value9) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 Ennead 类的作用。我们将在其中看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

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]

JavaTuples - LabelValues Class

Introduction

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

Class Declaration

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

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) 这创建一个 LabelValue 元组。

Class Methods

Sr.No.

Method & Description

1

static &lt;X&gt; LabelValue&lt;X,X&gt; fromArray(X[] array) 从数组创建元组。

2

static &lt;X&gt; LabelValue&lt;X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

3

static &lt;X&gt; LabelValue&lt;X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

4

static &lt;X&gt; LabelValue&lt;X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从指定索引开始创建元组。

5

A getLabel() Return the label.

6

int getSize() 返回元组的大小。

7

A getValue() 返回元组的值。

8

&lt;X&gt; LabelValue&lt;X,B&gt; setLabel(X label) 设置标签并返回元组。

9

&lt;X&gt; LabelValue&lt;A,Y&gt; setValue(Y value) 设置值并返回元组。

10

static &lt;A,B&gt; LabelValue&lt;A,B&gt; with(A value0, B value1) 使用给定值创建元组。

Methods inherits

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

我们来看一下 LabelValue 类的实际应用。在这里，我们将看到如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

JavaTuples - KeyValue Class

Introduction

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

Class Declaration

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

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) 这会创建一个 KeyValue 元组。

Class Methods

Sr.No.

Method & Description

1

static &lt;X&gt; KeyValue&lt;X,X&gt; fromArray(X[] array) 从数组创建元组。

2

static &lt;X&gt; KeyValue&lt;X,X&gt; fromCollection(Collection&lt;X&gt; collection) 从集合创建元组。

3

static &lt;X&gt; KeyValue&lt;X,X&gt; fromIterable(Iterable&lt;X&gt; iterable) 从可迭代对象创建元组。

4

static &lt;X&gt; KeyValue&lt;X,X&gt; fromIterable(Iterable&lt;X&gt; iterable, int index) 从可迭代对象创建元组，从指定索引开始。

5

A getKey() Return the key.

6

int getSize() 返回元组的大小。

7

A getValue() 返回元组的值。

8

&lt;X&gt; KeyValue&lt;X,B&gt; setKey(X key) 设置标签并返回元组。

9

&lt;X&gt; KeyValue&lt;A,Y&gt; setValue(Y value) 设置值并返回元组。

10

static &lt;A,B&gt; KeyValue&lt;A,B&gt; with(A value0, B value1) 使用给定值创建元组。

Methods inherite

此类从以下类中继承方法：

  1. org.javatuples.Tuple

  2. Object

Example

让我们看看 KeyValue 类的实际操作。我们将在其中了解如何使用各种方法。

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Pair Using Unit Class

Problem Description

如何使用 Unit 类实现 Pair 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Triplet Using Pair Class

Problem Description

如何使用 Pair 类实现 Triplet 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Quartet Using Triplet Class

Problem Description

如何使用 Triplet 类实现 Quartet 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Quintet Using Quartet Class

Problem Description

如何使用 Quartet 类来实现 Quintet 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Sextet Using Quintet Class

Problem Description

如何使用 Quintet 类实现 Sextet 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Septet using Sextet Class

Problem Description

如何使用 Sextet 类实现 Septet 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Octet using Septet Class

Problem Description

如何使用 Septet 类实现 Octet 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Ennead Using Octet Class

Problem Description

如何使用 Octet 类实现 Ennead 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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

Implementing Decade Using Ennead Class

Problem Description

如何使用 Ennead 类实现 Decade 类？

Example

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

在 C:&gt;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);
   }
}

Verify the result

使用以下 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

Output

验证输出

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