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]