JavaTuples-クイックガイド
タプル
タプルは、同じタイプである場合とそうでない場合があるオブジェクトのシーケンスです。次の例を考えてみましょう-
[12,"TutorialsPoint", java.sql.Connection@li757b]上記のオブジェクトは、整数、文字列、接続オブジェクトの3つの要素のタプルです。
JavaTuple
JavaTuplesは非常に単純なライブラリであり、タプル関連の要件のほとんどを処理するのに十分な10の異なるタプルクラスを提供します。
Unit <A> -1要素
ペア<A、B> -2要素
トリプレット<A、B、C> -3要素
カルテット<A、B、C、D> -4要素
クインテット<A、B、C、D、E> -5要素
セクステット<A、B、C、D、E、F> -6要素
セプテット<A、B、C、D、E、F、G> -7要素
オクテット<A、B、C、D、E、F、G、H> -8要素
Ennead <A、B、C、D、E、F、G、H、I> -9要素
Decade <A、B、C、D、E、F、G、H、I、J> -10要素
これらのタプルクラスとは別に、JavaTuplesはセマンティクスのために2つの追加クラスも提供します。
KeyValue<A,B>
LabelValue<A,B>
すべてのタプルクラスはタイプセーフで不変であり、次のインターフェイスとメソッドを実装します。
Iterable
Serializable
Comparable<Tuple>
equals()
hashCode()
toString()
タプルとリスト/配列
リストまたは配列には任意の数の要素を含めることができますが、各要素は同じタイプである必要がありますが、タプルには特定の数の要素のみを含めることができ、異なるタイプの要素を持つことができますが、それでもタイプセーフです。
ローカル環境のセットアップ
それでも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：\ ProgramFiles \ java \ jdk \ bin」に変更します。
Windows 95/98 / Mのパスの設定
Javaがc：\ Program Files \ java \ jdkディレクトリにインストールされていることを前提としています-
'C：\ autoexec.bat'ファイルを編集し、最後に次の行を追加します-'SET PATH =％PATH％; C：\ Program Files \ java \ jdk \ bin '
Linux、UNIX、Solaris、FreeBSのパスの設定
環境変数PATHは、Javaバイナリがインストールされている場所を指すように設定する必要があります。これを行うのに問題がある場合は、シェルのドキュメントを参照してください。
たとえば、シェルとしてbashを使用する場合は、「。bashrc：export PATH = / path / to / java：$ PATH」の末尾に次の行を追加します。
人気のJavaエディター
Javaプログラムを作成するには、テキストエディタが必要です。市場には多くの洗練されたIDEがあります。しかし今のところ、あなたは次のいずれかを考えることができます-
Notepad − Windowsマシンでは、メモ帳（このチュートリアルに推奨）、TextPadなどの単純なテキストエディターを使用できます。
Netbeans−これはオープンソースで無料のJava IDEであり、www.netbeans.org /index.htmlからダウンロードできます。
Eclipse−これはEclipseオープンソースコミュニティによって開発されたJava IDEでもあり、www.eclipse.orgからダウンロードできます。
JavaTuplesArchieをダウンロードする
Mavenリポジトリから最新バージョンのJavaTuplesjarファイルをダウンロードします-JavaTuples。このチュートリアルでは、javatuples-1.2.jarがダウンロードされ、C：\> javatuplesフォルダーにコピーされます。
| OS | アーカイブ名 |
|---|---|
| ウィンドウズ | javatuples-1.2.jar |
| Linux | javatuples-1.2.jar |
| マック | javatuples-1.2.jar |
JavaTuples環境を設定する
をセットする JavaTuplesJavaTuplesjarがマシンに保存されているベースディレクトリの場所を指す環境変数。次のように、さまざまなオペレーティングシステムのJavaTuplesフォルダーにjavatuples-1.2.jarを抽出したと仮定します。
| OS | 出力 |
|---|---|
| ウィンドウズ | 環境変数JavaTuplesをC：\ JavaTuplesに設定します |
| Linux | JavaTuples = / usr / local / JavaTuplesをエクスポートします |
| マック | JavaTuples = / Library / JavaTuplesをエクスポートします |
CLASSPATH変数を設定する
をセットする CLASSPATHJavaTuplesjarの場所を指す環境変数。次のように、さまざまなオペレーティングシステムのJavaTuplesフォルダーにjavatuples-1.2.jarを保存したと仮定します。
| OS | 出力 |
|---|---|
| ウィンドウズ | 環境変数CLASSPATHを％CLASSPATH％;％JavaTuples％\ javatuples-1.2.jar;。;に設定します。 |
| Linux | export CLASSPATH = $ CLASSPATH：$ JavaTuples /javatuples-1.2.jar:。 |
| マック | export CLASSPATH = $ CLASSPATH：$ JavaTuples /javatuples-1.2.jar:。 |
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の動作を見てみましょう。ここでは、さまざまな方法を使用してタペルを作成する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[Test, 5]
[Test, 5]
[1, 2]
[6, 8]タプルには、値を取得するためのgetValueX（）メソッドと、インデックスによって値を取得するための汎用メソッドgetValue（）があります。たとえば、Tripletクラスには次のメソッドがあります。
getValue(index) −0から始まるインデックスの値を返します。
getValue0() −インデックス0の値を返します。
getValue1() −インデックス1の値を返します。
getValue2() −インデックス2の値を返します。
特徴
getValueX（）メソッドはタイプセーフであり、キャストは必要ありませんが、getValue（index）は汎用です。
タプルには、要素数までのgetValueX（）メソッドがあります。たとえば、TripletにはgetValue3（）メソッドがありませんが、Quartetにはあります。
セマンティッククラスKeyValueおよびLabelValueには、getValue0（）/ getValue1（）メソッドの代わりにgetKey（）/ getValue（）およびgetLabel（）/ getValue（）があります。
例
JavaTuplesの動作を見てみましょう。ここでは、さまざまな方法を使用してタプルから値を取得する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
Test
5
Test
5
Test
5タプルには、特定のインデックスに値を設定するためのsetAtX（）メソッドがあります。たとえば、Tripletクラスには次のメソッドがあります。
setAt0() −インデックス0に値を設定します。
setAt1() −インデックス1に値を設定します。
setAt2() −インデックス2に値を設定します。
特徴
タプルは不変です。各setAtX（）は、更新された値を確認するために使用される新しいタプルを返します。
タプルの位置のタイプは、setAtX（）メソッドを使用して変更できます。
例
JavaTuplesの動作を見てみましょう。ここでは、さまざまな方法を使用してタプルに値を設定する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
Original Pair: [Test, 5]
Updated Pair:[Updated Value, 5]
Original Pair: [Test, 5]
Changed Pair:[Test, Changed Type]タプルの最後にadd（）メソッドがあり、タプルのタイプも変更します。たとえば、要素をトリプレットタプルに追加すると、それがカルテットタプルに変換されます。
Quartet<String,String,String,String> quartet = triplet.add("Test");タプルには、0から始まる特定のインデックスに位置を追加するためのaddAtX（）メソッドもあります。
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の動作を見てみましょう。ここでは、さまざまな方法を使用してタプルに値を追加する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
Pair: [Test, 5]
Triplet:[Test, 5, Test2]
Quartet:[Test, Test1, 5, Test2]
Quintet:[Test, 5, Test2, Test, 5]タプルには、特定のインデックスの値を削除するためのremoveAtX（）メソッドがあります。たとえば、Tripletクラスには次のメソッドがあります。
removeAt0() −インデックス0の値を削除し、結果のタプルを返します。
removeAt1() −インデックス1の値を削除し、結果のタプルを返します。
removeAt2() −インデックス2の値を削除し、結果のタプルを返します。
要素を削除すると、新しいタプルが返されます。
例
JavaTuplesの動作を見てみましょう。ここでは、タプルの値を削除する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
Triplet:[Test1, 5, Test2]
Pair: [Test1, 5]タプルからリスト/配列へ
タプルはリスト/配列に変換できますが、タイプの安全性を犠牲にして、変換されたリストはタイプ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の動作を見てみましょう。ここでは、タプルをリスト/配列に、またはその逆に変換する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
Triplet:[Test1, 5, Test2]
List: [Test1, 5, Test2]
Test1 5 Test2
Quartet:[a, b, c, d]各タプルはIterableインターフェースを実装し、コレクションと同様の方法で反復できます。
Pair<String, Integer> pair = Pair.with("Test", Integer.valueOf(5));
for(Object object: Pair){
System.out.println(object);
}例
JavaTuplesの動作を見てみましょう。ここでは、タプルを反復処理する方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
Test1 5 Test2
[Test1, 5, Test2]
a b c d
Quartet:[a, b, c, d]各タプルは、コレクションと同様の方法で要素をチェックするためのユーティリティメソッドを提供します。
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の動作を見てみましょう。ここでは、タプル内の要素をチェックする方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[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前書き
ザ・ org.javatuples.Unit classは、単一の要素を持つタプルを表します。
クラス宣言
以下はの宣言です org.javatuples.Unit クラス-
public final class Unit<A>
extends Tuple
implements IValue0<A>クラスコンストラクター
| シニア番号 | コンストラクターと説明 |
|---|---|
| 1 | Unit(A value0) これにより、ユニットタプルが作成されます。 |
クラスメソッド
| シニア番号 | 方法と説明 |
|---|---|
| 1 | Pair add(Unit tuple) このメソッドはペアタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、add（Pair tuple）はトリプレットを返し、upto add（Ennead tuple）はDecadeタプルを返します。 |
| 2 | Pair add(X0 value) このメソッドはタプルに値を追加し、ペアタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、add（X0 value0、X1 value1）は、9つのパラメーターを持つadd（）までトリプレットなどを返します。 |
| 3 | Pair addAt0(Unit value) このメソッドは、インデックス0にユニットタプルを追加し、ペアタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、addAt0（ペア値）はトリプレットを返し、以下同様にaddAt0（Ennead）まで戻ります。他の同様のメソッドは、index0にユニットを追加し、addAt1（Ennead）まで同様のメソッドを持つaddAt1（Unit value）です。 |
| 4 | Pair addAt0(X0 value) このメソッドは、インデックス0に値を追加し、ペアタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、addAt0（X0 value0、X1 value1）は、9つのパラメーターを持つaddAt0（）までトリプレットなどを返します。他の同様のメソッドは、index0に値を追加し、9つのパラメーターを持つaddAt1（）まで同様のメソッドを持つaddAt1（X0 value）です。 |
| 5 | static <X> Unit<X> fromArray(X[] array) 配列からタプルを作成します。 |
| 6 | static <X> Unit<X> fromCollection(Collection<X> collection) コレクションからタプルを作成します。 |
| 7 | static <X> Unit<X> fromIterable(Iterable<X> iterable) iterableからタプルを作成します。 |
| 8 | static <X> Unit<X> fromIterable(Iterable<X> iterable, int index) 指定されたインデックスから開始して、iterableからタプルを作成します。 |
| 9 | int getSize() タプルのサイズを返します。 |
| 10 | A getValue0() タプルの値を返します。 |
| 11 | <X> Unit<X> setAt0(X value) タプルの値を設定します。 |
| 12 | static <A> Unit<A> with(A value0) 指定された値を使用してタプルを作成します。 |
メソッドは継承します
このクラスは、次のクラスからメソッドを継承します-
org.javatuples.Tuple
Object
例
ユニットクラスの動作を見てみましょう。ここでは、さまざまな方法の使用方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[5]
5 is present: true
[5, Test]
5
[1]前書き
ザ・ org.javatuples.Pair classは、2つの要素を持つタプルを表します。
クラス宣言
以下はの宣言です org.javatuples.Pair クラス-
public final class Pair<A,B>
extends Tuple
implements IValue0<A>, IValue1<B>クラスコンストラクタ
| シニア番号 | コンストラクターと説明 |
|---|---|
| 1 | Pair(A value0, B value1) これにより、ペアタプルが作成されます。 |
クラスメソッド
同様に、setAt1（）はインデックス1に値を設定します。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | Triplet add(Unit tuple) このメソッドはトリプレットタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、add（Pair tuple）はQuartetを返し、upto add（Octet tuple）はDecadeタプルを返します。 |
| 2 | Triplet add(X0 value) このメソッドはタプルに値を追加し、トリプレットタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、add（X0 value0、X1 value1）は、8つのパラメーターを持つadd（）までQuartetなどを返します。 |
| 3 | Triplet addAt0(Unit value) このメソッドは、インデックス0にユニットタプルを追加し、トリプレットタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、addAt0（Pair value）はQuartetを返し、以下同様にaddAt0（Octet）まで戻ります。他の同様のメソッドは、index0にユニットを追加し、addAt2（Octet）まで同様のメソッドを持つaddAt1（Unit value）です。 |
| 4 | Triplet addAt0(X0 value) このメソッドは、インデックス0に値を追加し、トリプレットタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、addAt0（X0 value0、X1 value1）は、8つのパラメーターを持つaddAt0（）までのQuartetなどを返します。他の同様のメソッドは、index0に値を追加し、8つのパラメーターを持つaddAt2（）までの同様のメソッドを持つaddAt1（X0 value）です。 |
| 5 | static <X> Pair<X,X> fromArray(X[] array) 配列からタプルを作成します。 |
| 6 | static <X> Pair<X,X> fromCollection(Collection<X> collection) コレクションからタプルを作成します。 |
| 7 | static <X> Pair<X,X> fromIterable(Iterable<X> iterable) iterableからタプルを作成します。 |
| 8 | static <X> Pair<X,X> fromIterable(Iterable<X> iterable, int index) 指定されたインデックスから開始して、iterableからタプルを作成します。 |
| 9 | int getSize() タプルのサイズを返します。 |
| 10 | A getValue0() インデックス0のタプルの値を返します。 同様に、getValue1（）はインデックス1の値を返します。 |
| 11 | Unit<B> removeFrom0() インデックス0のタプルの値を削除した後、タプルを返します。 同様に、removeFrom1（）は、インデックス1のタプルの値を削除した後、タプルを返します。 |
| 12 | <X> Pair<X,B> setAt0(X value) タプルの値をインデックス0に設定します。 |
| 13 | static <A,B> Pair<A,B> with(A value0, B value1) 指定された値を使用してタプルを作成します。 |
メソッドは継承します
このクラスは、次のクラスからメソッドを継承します-
org.javatuples.Tuple
Object
例
ペアクラスの動作を見てみましょう。ここでは、さまざまな方法の使用方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[5, 6]
5 is present: true
[5, 6, Test]
5
[6]
[1, 2]前書き
ザ・ org.javatuples.Triplet classは、3つの要素を持つタプルを表します。
クラス宣言
以下はの宣言です org.javatuples.Triplet クラス-
public final class Triplet<A,B,C>
extends Tuple
implements IValue0<A>, IValue1<B>, IValue2<C>クラスコンストラクタ
| シニア番号 | コンストラクターと説明 |
|---|---|
| 1 | Triplet(A value0, B value1, C value2) これにより、トリプレットタプルが作成されます。 |
クラスメソッド
同様に、setAt1（）からsetAt2（）までは、インデックス1に値を設定します。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | Quartet add(Unit tuple) このメソッドは、Quartetタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、add（Pair tuple）はQuintetを返し、upto add（Septet tuple）はDecadeタプルを返します。 |
| 2 | Quartet add(X0 value) このメソッドはタプルに値を追加し、Quartetタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、add（X0 value0、X1 value1）はQuintetを返し、7つのパラメーターを持つadd（）まで続きます。 |
| 3 | Quartet addAt0(Unit value) このメソッドは、インデックス0にUnitタプルを追加し、Quartetタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、addAt0（Pair value）はQuintetを返し、以下同様にaddAt0（Septet）まで戻ります。他の同様のメソッドは、index0にユニットを追加し、addAt2（Septet）まで同様のメソッドを持つaddAt1（ユニット値）です。 |
| 4 | Quartet addAt0(X0 value) このメソッドは、インデックス0に値を追加し、Quartetタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、addAt0（X0 value0、X1 value1）は、7つのパラメーターを持つaddAt0（）までQuintetなどを返します。他の同様のメソッドは、index0に値を追加し、7つのパラメーターを持つaddAt2（）まで同様のメソッドを持つaddAt1（X0 value）です。 |
| 5 | static <X> Triplet<X,X,X> fromArray(X[] array) 配列からタプルを作成します。 |
| 6 | static <X> Triplet<X,X,X> fromCollection(Collection<X> collection) コレクションからタプルを作成します。 |
| 7 | static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable) iterableからタプルを作成します。 |
| 8 | static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable, int index) 指定されたインデックスから開始して、iterableからタプルを作成します。 |
| 9 | int getSize() タプルのサイズを返します。 |
| 10 | A getValue0() インデックス0のタプルの値を返します。 同様に、getValue1（）からgetValue2（）までは、インデックス1の値を返します。 |
| 11 | Pair<B,C> removeFrom0() インデックス0のタプルの値を削除した後、タプルを返します。 同様に、removeFrom1（）からremoveFrom2（）までは、インデックス1のタプルの値を削除した後、タプルを返します。 |
| 12 | <X> Triplet<X,B,C> setAt0(X value) タプルの値をインデックス0に設定します。 |
| 13 | static <A> Triplet<A,B,C> with(A value0, B value1, C value2) 指定された値を使用してタプルを作成します。 |
メソッドは継承します
このクラスは、次のクラスからメソッドを継承します-
org.javatuples.Tuple
Object
例
トリプレットクラスの動作を見てみましょう。ここでは、さまざまな方法の使用方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[5, 6, 7]
5 is present: true
[5, 6, 7, Test]
5
[6, 7]
[1, 2, 3]前書き
ザ・ org.javatuples.Quartet classは、4つの要素を持つタプルを表します。
クラス宣言
以下はの宣言です org.javatuples.Quartet クラス-
public final class Quartet<A, B, C, D>
extends Tuple
implements IValue0<A>, IValue1<B>, IValue2<C>, IValue3<D>クラスコンストラクタ
| シニア番号 | コンストラクターと説明 |
|---|---|
| 1 | Quartet(A value0, B value1, C value2, D value3) これにより、カルテットタプルが作成されます。 |
クラスメソッド
同様に、setAt1（）からsetAt3（）までは、インデックス1に値を設定します。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | Quintet add(Unit tuple) このメソッドはQuintetタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、add（Pair tuple）はSextetを返し、upto add（Sextet tuple）はDecadeタプルを返します。 |
| 2 | Quintet add(X0 value) このメソッドはタプルに値を追加し、Quintetタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、add（X0 value0、X1 value1）は、6つのパラメーターを持つadd（）までSextetなどを返します。 |
| 3 | Quintet addAt0(Unit value) このメソッドは、インデックス0にユニットタプルを追加し、クインテットタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、addAt0（Pair value）はSextetを返し、以下同様にaddAt0（Sextet）まで戻ります。他の同様のメソッドは、index0にユニットを追加し、addAt2（Sextet）まで同様のメソッドを持つaddAt1（Unit value）です。 |
| 4 | Quintet addAt0(X0 value) このメソッドは、インデックス0に値を追加し、クインテットタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、addAt0（X0 value0、X1 value1）は、6つのパラメーターを持つaddAt0（）までSextetなどを返します。他の同様のメソッドは、index0に値を追加し、6つのパラメーターを持つaddAt2（）まで同様のメソッドを持つaddAt1（X0 value）です。 |
| 5 | static <X> Quartet<X,X,X,X> fromArray(X[] array) 配列からタプルを作成します。 |
| 6 | static <X> Quartet<X,X,X,X> fromCollection(Collection<X> collection) コレクションからタプルを作成します。 |
| 7 | static <X> Quartet<X,X,X,X> fromIterable(Iterable<X> iterable) iterableからタプルを作成します。 |
| 8 | static <X> Quartet<X,X,X,X> fromIterable(Iterable<X> iterable, int index) 指定されたインデックスから開始して、iterableからタプルを作成します。 |
| 9 | int getSize() タプルのサイズを返します。 |
| 10 | A getValue0() インデックス0のタプルの値を返します。 同様に、getValue1（）からgetValue3（）までは、インデックス1の値を返します。 |
| 11 | Triplet<B,C,D> removeFrom0() インデックス0のタプルの値を削除した後、タプルを返します。 同様に、removeFrom1（）からremoveFrom3（）までは、インデックス1のタプルの値を削除した後、タプルを返します。 |
| 12 | <X> Quartet<X,B,C,D> setAt0(X value) タプルの値をインデックス0に設定します。 |
| 13 | static <A> Quartet<A,B,C,D> with(A value0, B value1, C value2, D value3) 指定された値を使用してタプルを作成します。 |
メソッドは継承します
このクラスは、次のクラスからメソッドを継承します-
org.javatuples.Tuple
Object
例
カルテットクラスの動作を見てみましょう。ここでは、さまざまな方法の使用方法を説明します。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[5, 6, 7, 8]
5 is present: true
[5, 6, 7, 8, Test]
5
[6, 7, 8]
[1, 2, 3, 4]前書き
ザ・ org.javatuples.Quintet classは、5つの要素を持つタプルを表します。
クラス宣言
以下はの宣言です 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>クラスコンストラクタ
| シニア番号 | コンストラクターと説明 |
|---|---|
| 1 | Quintet(A value0, B value1, C value2, D value3, E value4) これにより、クインテットタプルが作成されます。 |
クラスメソッド
同様に、setAt1（）からsetAt4（）までは、インデックス1に値を設定します。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | Sextet add(Unit tuple) このメソッドは、Sextetタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、add（Pair tuple）はSeptetを返し、upto add（Quintet tuple）はDecadeタプルを返します。 |
| 2 | Sextet add(X0 value) このメソッドはタプルに値を追加し、Sextetタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、add（X0 value0、X1 value1）はSeptetを返し、5つのパラメーターを持つadd（）まで続きます。 |
| 3 | Sextet addAt0(Unit value) このメソッドは、インデックス0にUnitタプルを追加し、Sextetタプルを返します。 同様に、タプルを追加する他のメソッドも使用できます。たとえば、addAt0（Pair value）はSeptetを返し、以下同様にaddAt0（Quintet）まで戻ります。他の同様のメソッドは、index0にユニットを追加し、addAt4（Quintet）まで同様のメソッドを持つaddAt1（Unit value）です。 |
| 4 | Sextet addAt0(X0 value) このメソッドは、インデックス0に値を追加し、Sextetタプルを返します。 同様に、値を追加する他のメソッドも使用できます。たとえば、addAt0（X0 value0、X1 value1）は、5つのパラメーターを持つaddAt0（）までSeptetなどを返します。他の同様のメソッドは、index0に値を追加し、5つのパラメーターを持つaddAt4（）までの同様のメソッドを持つaddAt1（X0 value）です。 |
| 5 | static <X> Quintet<X,X,X,X,X> fromArray(X[] array) 配列からタプルを作成します。 |
| 6 | static <X> Quintet<X,X,X,X,X> fromCollection(Collection<X> collection) コレクションからタプルを作成します。 |
| 7 | static <X> Quintet<X,X,X,X,X> fromIterable(Iterable<X> iterable) iterableからタプルを作成します。 |
| 8 | static <X> Quintet<X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) 指定されたインデックスから開始して、iterableからタプルを作成します。 |
| 9 | int getSize() タプルのサイズを返します。 |
| 10 | A getValue0() インデックス0のタプルの値を返します。 同様に、getValue1（）からgetValue4（）までは、インデックス1の値を返します。 |
| 11 | Quartet<B,C,D,E> removeFrom0() インデックス0のタプルの値を削除した後、タプルを返します。 同様に、removeFrom1（）からremoveFrom4（）までは、インデックス1のタプルの値を削除した後、タプルを返します。 |
| 12 | <X> Quintet<X,B,C,D,E> setAt0(X value) タプルの値をインデックス0に設定します。 |
| 13 | static <A> Quintet<A,B,C,D,E> with(A value0, B value1, C value2, D value3, E value4) 指定された値を使用してタプルを作成します。 |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see Quintet Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Quartet;
import org.javatuples.Quintet;
import org.javatuples.Sextet;
import org.javatuples.Triplet;
public class TupleTester {
public static void main(String args[]){
Quintet<Integer, Integer, Integer, Integer, Integer> quintet
= Quintet.with(5, 6, 7,8,9);
System.out.println(quintet);
boolean isPresent = quintet.contains(5);
System.out.println("5 is present: " + isPresent);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
Sextet<Integer, Integer, Integer, Integer, Integer, String> sextet
= quintet.add("Test");
System.out.println(sextet);
Integer value = quintet.getValue0();
System.out.println(value);
Quartet<Integer, Integer, Integer, Integer> quartet = quintet.removeFrom0();
System.out.println(quartet);
Quintet<Integer, Integer, Integer, Integer, Integer> quintet1
= Quintet.fromCollection(list);
System.out.println(quintet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9]
5 is present: true
[5, 6, 7, 8, 9, Test]
5
[6, 7, 8, 9]
[1, 2, 3, 4, 5]Introduction
The org.javatuples.Sextet class represents a Tuple with six elements.
Class Declaration
Following is the declaration for org.javatuples.Sextet class −
public final class Sextet<A, B, C, D, E, F>
extends Tuple
implements IValue0<A>, IValue1<B>,
IValue2<C>, IValue3<D>, IValue4<E>,
IValue5<F>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | Sextet(A value0, B value1, C value2, D value3, E value4, F value5) This creates a Sextet Tuple. |
Class Methods
Similarly setAt1() upto setAt5() set the value at index 1, and so on.
| Sr.No. | Method & Description |
|---|---|
| 1 | Septet add(Unit tuple) This method returns a Septet tuple. Similarly other methods to add tuples are available e.g. add(Pair tuple) returns Octet and upto add(Quartet tuple) returns Decade tuple. |
| 2 | Septet add(X0 value) This method add a value to the tuple and returns a Septet tuple. Similarly other methods to add values are available e.g. add(X0 value0, X1 value1) returns Octet and so on upto add() with four parameters. |
| 3 | Septet addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Septet tuple. Similarly other methods to add tuples are available e.g. addAt0(Pair value) returns Octet and so on upto addAt0(Quartet). Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt5(Quartet). |
| 4 | Septet addAt0(X0 value) This method add a value at index 0 and returns a Septet tuple. Similarly other methods to add values are available e.g. addAt0(X0 value0, X1 value1) returns Octet and so on upto addAt0() with four parameters. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt5() with four parameters. |
| 5 | static <X> Sextet<X,X,X,X,X,X> fromArray(X[] array) Create tuple from array. |
| 6 | static <X> Sextet<X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 7 | static <X> Sextet<X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 8 | static <X> Sextet<X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 9 | int getSize() Return the size of the tuple. |
| 10 | A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue5() returns the value at index 1 and so on. |
| 11 | Quintet<B,C,D,E,F> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom5() returns the tuple after removing value of the tuple at index 1 and so on. |
| 12 | <X> Sextet<X,B,C,D,E,F> setAt0(X value) Set the value of the tuple at index 0. |
| 13 | static <A> Sextet<A,B,C,D,E,F> with(A value0, B value1, C value2, D value3, E value4, F value5) Create the tuple using given value. |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see Sextet Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Quartet;
import org.javatuples.Quintet;
import org.javatuples.Sextet;
import org.javatuples.Septet;
public class TupleTester {
public static void main(String args[]){
Sextet<Integer, Integer, Integer, Integer, Integer,Integer> sextet
= Sextet.with(5, 6, 7,8,9,10);
System.out.println(sextet);
boolean isPresent = sextet.contains(5);
System.out.println("5 is present: " + isPresent);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Septet<Integer, Integer, Integer, Integer, Integer, Integer, String> septet
= sextet.add("Test");
System.out.println(septet);
Integer value = sextet.getValue0();
System.out.println(value);
Quintet<Integer, Integer, Integer, Integer,Integer> quintet
= sextet.removeFrom0();
System.out.println(quintet);
Sextet<Integer, Integer, Integer, Integer, Integer,Integer> sextet1
= Sextet.fromCollection(list);
System.out.println(sextet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10]
5 is present: true
[5, 6, 7, 8, 9, 10, Test]
5
[6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6]Introduction
The org.javatuples.Septet class represents a Tuple with seven elements.
Class Declaration
Following is the declaration for org.javatuples.Septet class −
public final class Septet<A, B, C, D, E, F, G>
extends Tuple
implements IValue0<A>, IValue1<B>,
IValue2<C>, IValue3<D>, IValue4<E>,
IValue5<F>, IValue6<G>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | Septet(A value0, B value1, C value2, D value3, E value4, F value5, G value6) This creates a Septet Tuple. |
Class Methods
Similarly setAt1() upto setAt6() set the value at index 1, and so on.
| Sr.No. | Method & Description |
|---|---|
| 1 | Octet add(Unit tuple) This method returns a Octet tuple. Similarly other methods to add tuples are available e.g. add(Pair tuple) returns Ennead and upto add(Triplet tuple) returns Decade tuple. |
| 2 | Octet add(X0 value) This method add a value to the tuple and returns a Octet tuple. Similarly other methods to add values are available e.g. add(X0 value0, X1 value1) returns Ennead and so on upto add() with three parameters. |
| 3 | Octet addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Octet tuple. Similarly other methods to add tuples are available e.g. addAt0(Pair value) returns Ennead and so on upto addAt0(Triplet). Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt6(Triplet). |
| 4 | Octet addAt0(X0 value) This method add a value at index 0 and returns a Octet tuple. Similarly other methods to add values are available e.g. addAt0(X0 value0, X1 value1) returns Ennead and so on upto addAt0() with three parameters. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt6() with three parameters. |
| 5 | static <X> Septet<X,X,X,X,X,X,X> fromArray(X[] array) Create tuple from array. |
| 6 | static <X> Septet<X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 7 | static <X> Septet<X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 8 | static <X> Septet<X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 9 | int getSize() Return the size of the tuple. |
| 10 | A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue6() returns the value at index 1 and so on. |
| 11 | Sextet<B,C,D,E,F,G> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom6() returns the tuple after removing value of the tuple at index 1 and so on. |
| 12 | <X> Septet<X,B,C,D,E,F,G> setAt0(X value) Set the value of the tuple at index 0. |
| 13 | static <A> Septet<A,B,C,D,E,F,G> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6) Create the tuple using given value. |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see Septet Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Septet;
import org.javatuples.Sextet;
import org.javatuples.Octet;
public class TupleTester {
public static void main(String args[]){
Septet<Integer, Integer, Integer, Integer, Integer,Integer,Integer> septet
= Septet.with(5, 6, 7,8,9,10,11);
System.out.println(septet);
boolean isPresent = septet.contains(5);
System.out.println("5 is present: " + isPresent);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
Octet<Integer, Integer, Integer, Integer, Integer, Integer, Integer, String> octet
= septet.add("Test");
System.out.println(octet);
Integer value = septet.getValue0();
System.out.println(value);
Sextet<Integer, Integer, Integer, Integer,Integer, Integer> sextet
= septet.removeFrom0();
System.out.println(sextet);
Septet<Integer, Integer, Integer, Integer, Integer,Integer, Integer> septet1
= Septet.fromCollection(list);
System.out.println(septet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10, 11]
5 is present: true
[5, 6, 7, 8, 9, 10, 11, Test]
5
[6, 7, 8, 9, 10, 11]
[1, 2, 3, 4, 5, 6, 7]Introduction
The org.javatuples.Octet class represents a Tuple with eight elements.
Class Declaration
Following is the declaration for org.javatuples.Octet class −
public final class Octet<A, B, C, D, E, F, G, H>
extends Tuple
implements IValue0<A>, IValue1<B>,
IValue2<C>, IValue3<D>, IValue4<E>,
IValue5<F>, IValue6<G>, IValue7<H>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | Octet(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7) This creates a Octet Tuple. |
Class Methods
Similarly setAt1() upto setAt7() set the value at index 1, and so on.
| Sr.No. | Method & Description |
|---|---|
| 1 | Ennead add(Unit tuple) This method returns a Ennead tuple. Similarly other methods to add tuples are available e.g. add(Pair tuple) returns Decade. |
| 2 | Ennead add(X0 value) This method add a value to the tuple and returns a Ennead tuple. Similarly other methods to add values are available e.g. add(X0 value0, X1 value1) returns Decade. |
| 3 | Ennead addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Ennead tuple. Similarly other methods to add tuples are available e.g. addAt0(Pair value) returns Decade. Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt7(Pair). |
| 4 | Ennead addAt0(X0 value) This method add a value at index 0 and returns a Ennead tuple. Similarly other methods to add values are available e.g. addAt0(X0 value0, X1 value1) returns Decade. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt7() with two parameters. |
| 5 | static <X> Octet<X,X,X,X,X,X,X,X> fromArray(X[] array) Create tuple from array. |
| 6 | static <X> Octet<X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 7 | static <X> Octet<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 8 | static <X> Octet<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 9 | int getSize() Return the size of the tuple. |
| 10 | A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue7() returns the value at index 1 and so on. |
| 11 | Septet<B,C,D,E,F,G,H> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom7() returns the tuple after removing value of the tuple at index 1 and so on. |
| 12 | <X> Octet<X,B,C,D,E,F,G,H> setAt0(X value) Set the value of the tuple at index 0. |
| 13 | static <A> Octet<A,B,C,D,E,F,G,H> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7) Create the tuple using given value. |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see Octet Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Ennead;
import org.javatuples.Octet;
import org.javatuples.Septet;
public class TupleTester {
public static void main(String args[]){
Octet<Integer, Integer, Integer, Integer, Integer,Integer,Integer,Integer>
octet = Octet.with(5, 6, 7,8,9,10,11,12);
System.out.println(octet);
boolean isPresent = octet.contains(5);
System.out.println("5 is present: " + isPresent);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
Ennead<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, String>
ennead = octet.add("Test");
System.out.println(ennead);
Integer value = octet.getValue0();
System.out.println(value);
Septet<Integer, Integer, Integer, Integer,Integer, Integer,Integer>
septet = octet.removeFrom0();
System.out.println(septet);
Octet<Integer, Integer, Integer, Integer, Integer,Integer, Integer, Integer>
octet1 = Octet.fromCollection(list);
System.out.println(octet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10, 11, 12]
5 is present: true
[5, 6, 7, 8, 9, 10, 11, 12, Test]
5
[6, 7, 8, 9, 10, 11, 12]
[1, 2, 3, 4, 5, 6, 7, 8]Introduction
The org.javatuples.Ennead class represents a Tuple with nine elements.
Class Declaration
Following is the declaration for org.javatuples.Ennead class −
public final class Ennead<A, B, C, D, E, F, G, H, I>
extends Tuple
implements IValue0<A>, IValue1<B>,
IValue2<C>, IValue3<D>, IValue4<E>,
IValue5<F>, IValue6<G>, IValue7<H>,
IValue8<I>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | Ennead(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8) This creates a Ennead Tuple. |
Class Methods
Similarly setAt1() upto setAt8() set the value at index 1, and so on.
| Sr.No. | Method & Description |
|---|---|
| 1 | Decade add(Unit tuple) This method returns a Decade tuple. |
| 2 | Decade add(X0 value) This method add a value to the tuple and returns a Decade tuple. |
| 3 | Decade addAt0(Unit value) This method add a Unit tuple at index 0 and returns a Decade tuple. Other similar method are addAt1(Unit value) which add a unit at index0 and have similar methods upto addAt8(Unit). |
| 4 | Decade addAt0(X0 value) This method add a value at index 0 and returns a Decade tuple. Other similar method are addAt1(X0 value) which add a value at index0 and have similar methods upto addAt8() with one parameter. |
| 5 | static <X> Ennead<X,X,X,X,X,X,X,X,X > fromArray(X[] array) Create tuple from array. |
| 6 | static <X> Ennead<X,X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 7 | static <X> Ennead<X,X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 8 | static <X> Ennead<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 9 | int getSize() Return the size of the tuple. |
| 10 | A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue8() returns the value at index 1 and so on. |
| 11 | Octet<B,C,D,E,F,G,H,I> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom8() returns the tuple after removing value of the tuple at index 1 and so on. |
| 12 | <X> Ennead<X,B,C,D,E,F,G,H,I> setAt0(X value) Set the value of the tuple at index 0. |
| 13 | static <A> Ennead<A,B,C,D,E,F,G,H,I> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8) Create the tuple using given value. |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see Ennead Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Decade;
import org.javatuples.Ennead;
import org.javatuples.Octet;
public class TupleTester {
public static void main(String args[]){
Ennead<Integer, Integer, Integer, Integer, Integer,
Integer,Integer,Integer, Integer>
ennead = Ennead.with(5, 6, 7,8,9,10,11,12,13);
System.out.println(ennead);
boolean isPresent = ennead.contains(5);
System.out.println("5 is present: " + isPresent);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
list.add(9);
Decade<Integer, Integer, Integer, Integer, Integer,
Integer, Integer, Integer, Integer, String> decade = ennead.add("Test");
System.out.println(decade);
Integer value = ennead.getValue0();
System.out.println(value);
Octet<Integer, Integer, Integer, Integer,Integer,
Integer,Integer, Integer> octet = ennead.removeFrom0();
System.out.println(octet);
Ennead<Integer, Integer, Integer, Integer, Integer,
Integer, Integer, Integer,Integer> ennead1 = Ennead.fromCollection(list);
System.out.println(ennead1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10, 11, 12, 13]
5 is present: true
[5, 6, 7, 8, 9, 10, 11, 12, 13, Test]
5
[6, 7, 8, 9, 10, 11, 12, 13]
[1, 2, 3, 4, 5, 6, 7, 8, 9]Introduction
The org.javatuples.Decade class represents a Tuple with ten elements.
Class Declaration
Following is the declaration for org.javatuples.Decade class −
public final class Decade<A, B, C, D, E, F, G, H, I, J>
extends Tuple
implements IValue0<A>, IValue1<B>,
IValue2<C>, IValue3<D>, IValue4<E>,
IValue5<F>, IValue6<G>, IValue7<H>,
IValue8<I>, IValue9<J>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | Decade(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8, I value9 ) This creates a Decade Tuple. |
Class Methods
Similarly setAt1() upto setAt9() set the value at index 1, and so on.
| Sr.No. | Method & Description |
|---|---|
| 1 | static <X> Decade<X,X,X,X,X,X,X,X,X,X > fromArray(X[] array) Create tuple from array. |
| 2 | static <X> Decade<X,X,X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 3 | static <X> Decade<X,X,X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 4 | static <X> Decade<X,X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 5 | int getSize() Return the size of the tuple. |
| 6 | A getValue0() Returns the value of the tuple at index 0. Similarly getValue1() upto getValue9() returns the value at index 1 and so on. |
| 7 | Ennead<B,C,D,E,F,G,H,I,J> removeFrom0() Return the tuple after removing value of the tuple at index 0. Similarly removeFrom1() upto removeFrom9() returns the tuple after removing value of the tuple at index 1 and so on. |
| 8 | <X> Decade<X,B,C,D,E,F,G,H,I,J> setAt0(X value) Set the value of the tuple at index 0. |
| 9 | static <A> Decade<A,B,C,D,E,F,G,H,I,J> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7, I value8, I value9) Create the tuple using given value. |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see Ennead Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.Decade;
import org.javatuples.Ennead;
public class TupleTester {
public static void main(String args[]){
Decade<Integer, Integer, Integer, Integer,
Integer,Integer,Integer,Integer, Integer, Integer>
decade = Decade.with(5, 6, 7,8,9,10,11,12,13,14);
System.out.println(decade);
boolean isPresent = decade.contains(5);
System.out.println("5 is present: " + isPresent);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
list.add(9);
list.add(10);
Integer value = decade.getValue0();
System.out.println(value);
Ennead<Integer, Integer, Integer, Integer,Integer,
Integer,Integer, Integer, Integer> ennead = decade.removeFrom0();
System.out.println(ennead);
Decade<Integer, Integer, Integer, Integer, Integer,
Integer, Integer, Integer,Integer, Integer>
decade1 = Decade.fromCollection(list);
System.out.println(decade1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
5 is present: true
5
[6, 7, 8, 9, 10, 11, 12, 13, 14]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]Introduction
The org.javatuples.LabelValue class represents a Tuple with two elements with positions 0 and 1 renamed as "label" and "value", respectively.
Class Declaration
Following is the declaration for org.javatuples.LabelValue class −
public final class LabelValue<A,B>
extends Tuple
implements IValue0<A>, IValue1<B>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | LabelValue(A value0, B value1) This creates a LabelValue Tuple. |
Class Methods
| Sr.No. | Method & Description |
|---|---|
| 1 | static <X> LabelValue<X,X> fromArray(X[] array) Create tuple from array. |
| 2 | static <X> LabelValue<X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 3 | static <X> LabelValue<X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 4 | static <X> LabelValue<X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 5 | A getLabel() Return the label. |
| 6 | int getSize() Return the size of the tuple. |
| 7 | A getValue() Returns the value of the tuple. |
| 8 | <X> LabelValue<X,B> setLabel(X label) set the label and return the tuple. |
| 9 | <X> LabelValue<A,Y> setValue(Y value) set the value and return the tuple. |
| 10 | static <A,B> LabelValue<A,B> with(A value0, B value1) Create the tuple using given value. |
Methods inherits
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see LabelValue Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.LabelValue;
public class TupleTester {
public static void main(String args[]){
LabelValue<Integer, Integer> labelValue = LabelValue.with(5,6);
System.out.println(labelValue);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Integer label = labelValue.getLabel();
System.out.println(label);
Integer value = labelValue.getValue();
System.out.println(value);
LabelValue<Integer, Integer> labelValue1
= LabelValue.fromCollection(list);
System.out.println(labelValue1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6]
5
6
[1, 2]Introduction
The org.javatuples.KeyValue class represents a Tuple with two elements with positions 0 and 1 renamed as "key" and "value", respectively.
Class Declaration
Following is the declaration for org.javatuples.KeyValue class −
public final class KeyValue<A,B>
extends Tuple
implements IValue0<A>, IValue1<B>Class Constructor
| Sr.No. | Constructor & Description |
|---|---|
| 1 | KeyValue(A value0, B value1) This creates a KeyValue Tuple. |
Class Methods
| Sr.No. | Method & Description |
|---|---|
| 1 | static <X> KeyValue<X,X> fromArray(X[] array) Create tuple from array. |
| 2 | static <X> KeyValue<X,X> fromCollection(Collection<X> collection) Create tuple from collection. |
| 3 | static <X> KeyValue<X,X> fromIterable(Iterable<X> iterable) Create tuple from iterable. |
| 4 | static <X> KeyValue<X,X> fromIterable(Iterable<X> iterable, int index) Create tuple from iterable, starting from the specified index. |
| 5 | A getKey() Return the key. |
| 6 | int getSize() Return the size of the tuple. |
| 7 | A getValue() Returns the value of the tuple. |
| 8 | <X> KeyValue<X,B> setKey(X key) set the label and return the tuple. |
| 9 | <X> KeyValue<A,Y> setValue(Y value) set the value and return the tuple. |
| 10 | static <A,B> KeyValue<A,B> with(A value0, B value1) Create the tuple using given value. |
Methods inherite
This class inherits methods from the following classes −
org.javatuples.Tuple
Object
Example
Let's see KeyValue Class in action. Here we'll see how to use various methods.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.javatuples.KeyValue;
public class TupleTester {
public static void main(String args[]){
KeyValue<Integer, Integer> keyValue = KeyValue.with(5,6);
System.out.println(keyValue);
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Integer key = KeyValue.getKey();
System.out.println(key);
Integer value = KeyValue.getValue();
System.out.println(value);
KeyValue<Integer, Integer> keyValue1 = KeyValue.fromCollection(list);
System.out.println(keyValue1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6]
5
6
[1, 2]Problem Description
How to implement Pair class using Unit class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Pair;
import org.javatuples.Unit;
public class TupleTester {
public static void main(String args[]){
Unit<Integer> unit = Unit.with(5);
System.out.println(unit);
Pair<Integer, String> pair = unit.add("test");
Pair<String, Integer> pair1 = unit.addAt0("test");
System.out.println(pair);
System.out.println(pair1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5]
[5, test]
[test, 5]Problem Description
How to implement Triplet class using Pair class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Triplet;
import org.javatuples.Pair;
public class TupleTester {
public static void main(String args[]){
Pair<Integer, Integer> pair = Pair.with(5,6);
System.out.println(pair);
Triplet<Integer, Integer, String> triplet = pair.add("test");
Triplet<String, Integer, Integer> triplet1 = pair.addAt0("test");
System.out.println(triplet);
System.out.println(triplet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6]
[5, 6, test]
[test, 5, 6]Problem Description
How to implement Quartet class using Triplet class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Quartet;
import org.javatuples.Triplet;
public class TupleTester {
public static void main(String args[]){
Triplet<Integer, Integer, Integer> triplet = Triplet.with(5,6,7);
System.out.println(triplet);
Quartet<Integer, Integer, Integer, String> quartet = triplet.add("test");
Quartet<String, Integer, Integer, Integer> quartet1 = triplet.addAt0("test");
System.out.println(quartet);
System.out.println(quartet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7]
[5, 6, 7, test]
[test, 5, 6, 7]Problem Description
How to implement Quintet class using Quartet class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Quintet;
import org.javatuples.Quartet;
public class TupleTester {
public static void main(String args[]){
Quartet<Integer, Integer, Integer, Integer> quartet = Quartet.with(5,6,7,8);
System.out.println(quartet);
Quintet<Integer, Integer, Integer, Integer, String> quintet = quartet.add("test");
Quintet<String, Integer, Integer, Integer, Integer> quintet1 = quartet.addAt0("test");
System.out.println(quintet);
System.out.println(quintet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8]
[5, 6, 7, 8, test]
[test, 5, 6, 7, 8]Problem Description
How to implement Sextet class using Quintet class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Quintet;
import org.javatuples.Sextet;
public class TupleTester {
public static void main(String args[]){
Quintet<Integer, Integer, Integer, Integer, Integer> quintet
= Quintet.with(5,6,7,8,9);
System.out.println(quintet);
Sextet<Integer, Integer, Integer, Integer, Integer, String> sextet
= quintet.add("test");
Sextet<String, Integer, Integer, Integer, Integer, Integer> sextet1
= quintet.addAt0("test");
System.out.println(sextet);
System.out.println(sextet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9]
[5, 6, 7, 8, 9, test]
[test, 5, 6, 7, 8, 9]Problem Description
How to implement Septet class using Sextet class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Septet;
import org.javatuples.Sextet;
public class TupleTester {
public static void main(String args[]){
Sextet<Integer, Integer, Integer, Integer, Integer, Integer> sextet
= Sextet.with(5,6,7,8,9,10);
System.out.println(sextet);
Septet<Integer, Integer, Integer, Integer, Integer, Integer, String>
septet = sextet.add("test");
Septet<String, Integer, Integer, Integer, Integer, Integer, Integer>
septet1 = sextet.addAt0("test");
System.out.println(septet);
System.out.println(septet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10]
[5, 6, 7, 8, 9, 10, test]
[test, 5, 6, 7, 8, 9, 10]Problem Description
How to implement Octet class using Septet class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Octet;
import org.javatuples.Septet;
public class TupleTester {
public static void main(String args[]){
Septet<Integer, Integer, Integer, Integer, Integer, Integer,
Integer> septet = Septet.with(5,6,7,8,9,10,11);
System.out.println(septet);
Octet<Integer, Integer, Integer, Integer, Integer, Integer,
Integer, String> octet = septet.add("test");
Octet<String, Integer, Integer, Integer, Integer, Integer,
Integer, Integer> octet1 = septet.addAt0("test");
System.out.println(octet);
System.out.println(octet1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.javaNow run the TupleTester to see the result −
C:\JavaTuples>java -cp .;javatuples-1.2.jar com.tutorialspoint.TupleTesterOutput
Verify the Output
[5, 6, 7, 8, 9, 10, 11]
[5, 6, 7, 8, 9, 10, 11, test]
[test, 5, 6, 7, 8, 9, 10, 11]Problem Description
How to implement Ennead class using Octet class?
Example
Following example shows how to accomplish the above task. Each tuple has add() and addAtX() methods to convert the tuple.
Create a java class file named TupleTester in C:\>JavaTuples.
File: TupleTester.java
package com.tutorialspoint;
import org.javatuples.Ennead;
import org.javatuples.Octet;
public class TupleTester {
public static void main(String args[]){
Octet<Integer, Integer, Integer, Integer, Integer, Integer,
Integer, Integer> octet = Octet.with(5,6,7,8,9,10,11,12);
System.out.println(octet);
Ennead<Integer, Integer, Integer, Integer, Integer, Integer,
Integer, Integer, String> ennead = octet.add("test");
Ennead<String, Integer, Integer, Integer, Integer, Integer,
Integer, Integer, Integer> ennead1 = octet.addAt0("test");
System.out.println(ennead);
System.out.println(ennead1);
}
}Verify the result
Compile the classes using javac compiler as follows −
C:\JavaTuples>javac -cp javatuples-1.2.jar ./com/tutorialspoint/TupleTester.java次に、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クラスを実装するにはどうすればよいですか？
例
次の例は、上記のタスクを実行する方法を示しています。各タプルには、タプルを変換するためのadd（）メソッドとaddAtX（）メソッドがあります。
でTupleTesterという名前のJavaクラスファイルを作成します C:\>JavaTuples。
ファイル：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出力
出力を確認する
[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]