原文： https://howtodoinjava.com/java/basics/java-tuples/

在本 Java 教程中，我们将学习 Java 元组 – 通用数据结构，以及如何在 Java 程序中使用元组。 默认情况下，元组在 Java 编程语言中不作为数据结构出现，因此我们将使用一个不错的第三方库javatuples。

  1. Table of Contents
  3. 1\. What is tuple
  4. 2\. Tuple in Java
  5. 3\. Introduction of Javatuples 
  6. 4\. Common Operations on Javatuples
  7. 5\. Conclusion

1. 什么是元组？

元组可以看作是有序的不同类型的对象的集合。 这些对象不一定以任何方式相互关联，但是它们总的来说将具有一定的意义。

例如，["Sajal Chakraborty", "IT Professional", 32]可以是一个元组，其中该元组中的每个值都没有任何关系，但是整个值集在应用程序中可能具有某些意义。 例如，给定元组可以代表具有姓名，部门和年龄的员工数据。

让我们来看更多 java 元组示例。

  1. ["Java", 1.8, "Windows"]
  2. ["Alex", 32, "New York", true]
  3. [3, "Alexa", "howtodoinjava.com", 37000]

2. Java 中的元组

Java 没有任何这样的内置数据结构来支持元组。 无论何时需要，我们显然都可以创建一个类似于元组的类。

同样，在 Java 中，可以使用列表或数组来编写元组特性的一部分，但这些不允许我们通过设计保存不同类型的数据类型。 因此，可以说在 Java 中使用标准数据结构的异构元组是不可能的。

2.1 元组与列表/数组的比较

通常将元组与列表进行比较，因为它看起来非常像一个列表。 但是它们在某些方面有所不同。

  1. 元组是可以包含异构数据的对象。 列表旨在存储单一类型的元素。
  2. 在所有数据结构中，元组被认为是最快的，并且它们消耗的内存量最少。
  3. 虽然数组和列表是可变的，这意味着您可以更改其数据值并修改其结构，但元组是不可变的。
  4. 像数组一样，元组的大小也是固定的。 这就是为什么元组旨在完全替换数组的原因，因为它们在所有参数上都更有效率。
  5. 如果您有一个在生命周期内仅分配一次的数据集，并且其值不应再次更改，则需要一个元组。

3. javatuples库

3.1 javatuples maven 依赖

javatuples库存在于 Maven 中央存储库中，我们可以添加此依赖项以使用该库。

  1. <dependency>
  2.     <groupId>org.javatuples</groupId>
  3.     <artifactId>javatuples</artifactId>
  4.     <version>1.2</version>
  5. </dependency>

3.2 javatuples - 类

Java 元组支持最大为10的元组，并且对于每种大小，它都提供了如下的元组实现。

  • Unit（一个元素）
  • Pair（两个元素）
  • Triplet（三个元素）
  • Quartet（四个元素）
  • Quintet（五个元素）
  • Sextet（六个元素）
  • Septet（七个元素）
  • Octet（八个元素）
  • Ennead（九个元素）
  • Decade（十个元素）

除了上述类之外，它还提供了另外两个类来方便表示对。 大部分与Pair相同，但语法更详细。

  1. KeyValue
  2. LabelValue

3.3 javatuples – 特性

不同类型的 Java 元组是：

  1. 输入安全
  2. 不可变
  3. 可迭代的
  4. 可序列化
  5. 可比（实现Comparable）
  6. 实现equals()和hashCode()
  7. 实现toString()

4. javatuples的常见操作

4.1 创建元组

4.1.1 工厂方法

元组对象是通过每个元组类提供的工厂方法with() 构造的。 例如，我们可以使用创建Pair的元组。

  1. Pair<String, Integer> pair = Pair.with("Sajal", 12);

4.1.2 构造器

我们还可以使用Pair的构造器。

  1. Pair<String, Integer> person = new Pair<String, Integer>("Sajal", 12);

4.1.3 集合或可迭代对象

我们可以从Collection或Iterable创建元组，前提是该集合具有确切数量的对象。 在这种情况下，请记住，集合中的项目数应与我们要创建的元组的类型相匹配。

  1. //Collection of 4 elements will create Quartet
  2. List<String> listOf4Names = Arrays.asList("A1","A2","A3","A4");
  4. Quartet<String, String, String, String> quartet = Quartet.fromCollection(listOf4Names);
  6. System.out.println(quartet);
  8. //Create pair with items starting from the specified index.
  9. List<String> listOf4Names = Arrays.asList("A1","A2","A3","A4");
  11. Pair<String, String> pair1 = Pair.fromIterable(listOf4Names, 2);
  13. System.out.println(pair1);

程序输出。

  1. [A1, A2, A3, A4]
  2. [A3, A4]

同样，我们可以根据需要创建任何元组类的对象。

4.2 检索值

4.2.1 getValueX()方法

我们可以使用其索引的getValueX()方法从元组中获取值，其中'X'表示元组内部的元素位置。 例如getValue0()，getValue1()等。

  1. Pair<String, Integer> pair = Pair.with("Sajal", 12);
  3. System.out.println("Name : " + pair.getValue0());
  4. System.out.println("Exp : " + pair.getValue1());

程序输出：

  1. Name : Sajal
  2. Exp : 12

请注意，这些获取方法是类型安全的。 这意味着编译器已经基于用于初始化元组的元素值知道方法的返回类型。

4.2.2 getValue(int index)方法

元组还有另一种类型不安全的方法getValue(int index)。 因此，在分配变量时，需要将值转换为期望的类型。

  1. Pair<String, Integer> pair = Pair.with("Sajal", 12);
  3. System.out.println("Name : " + pair.getValue(0));
  4. System.out.println("Exp : " + pair.getValue(1));

程序输出：

  1. Name : Sajal
  2. Exp : 12

类KeyValue和LabelValue的方法分别为getKey()/getValue()和getLabel()/getValue()。

4.3 设定值

创建元组后，我们可以设置值。 我们可以通过setAtX()方法执行此操作，其中'X'是我们要设置值的索引位置。

  1. Pair<String, Integer> pair = Pair.with("Sajal", 12);
  3. //Modify the value
  4. Pair<String, Integer> modifiedPair = pair.setAt0("Kajal");
  6. System.out.println(pair);
  7. System.out.println(modifiedPair);

程序输出：

  1. [Sajal, 12]
  2. [Kajal, 12]

请注意，元组是不可变的。 因此，setAt()方法返回具有修改后值的相同类型的元组。 原始元组不变。

4.4 添加或删除元素

4.4.1 add()方法

我们还可以在元组中添加元素，这将返回与元素数量匹配的新元组类型。 例如，如果我们将元素值添加到Pair，那么我们将获得一个Triplet对象作为回报。

元组的末尾添加了新元素。

  1. Pair<String, Integer> pair = Pair.with("Sajal", 12);
  3. Triplet<String, Integer, String> triplet = pair.add("IT Professional");
  5. System.out.println(pair);
  6. System.out.println(triplet);

程序输出：

  1. [Sajal, 12]
  2. [Sajal, 12, IT Professional]

我们也可以将一个元组对象添加到另一个元组中。 它将根据添加后存在的元素数返回元组的类型。

  1. Triplet<String, String, String> triplet = Triplet.with("Java", "C", "C++");
  2. Quartet<String, String, String, String> quartet = triplet.addAt1("Python");
  4. Septet septet = quartet.add(triplet);   //3 + 4 = 7
  6. System.out.println(triplet);
  7. System.out.println(quartet);
  8. System.out.println(septet);

程序输出：

  1. [Java, C, C++]
  2. [Java, Python, C, C++]
  3. [Java, Python, C, C++, Java, C, C++]

4.4.2 join()方法

默认情况下，新元素添加到元组的末尾。 但是我们也可以使用addAtX()方法在元组的其他位置添加元素。

  1. Triplet<String, String, String> triplet = Triplet.with("Java", "C", "C++");
  2. Quartet<String, String, String, String> quartet = triplet.addAt1("Python");
  4. System.out.println(triplet);
  5. System.out.println(quartet);

程序输出：

  1. [Java, C, C++]
  2. [Java, Python, C, C++]

4.5 将元组转换为集合或数组

每个元组类提供asList()和toArray()方法，它们分别返回List和Array。

  1. //Convert to list
  2. Quartet<String, Integer, String, Double> quartet1 = Quartet.with("A1",1,"A3",2.3);
  4. List<Object> quartletList = quartet1.toList();
  6. System.out.println(quartletList);
  8. //Convert to array
  9. Object[] quartletArr = quartet1.toArray();
  11. System.out.println(Arrays.toString(quartletArr));

程序输出：

  1. [A1, 1, A3, 2.3]
  2. [A1, 1, A3, 2.3]

请注意，元组可以包含异构类型，因此相应的结果类型将为List<Object>或Object[]。

4.6 迭代

javatuples中的所有元组类都实现Iterable接口，因此可以与集合或数组相同的方式对其进行迭代。

  1. Quartet<String, Integer, String, Double> quartet1 = Quartet.with("A1",1,"A3",2.3);
  3. for(Object obj : quartet1) {
  4.     System.out.println(obj);
  5. }

程序输出：

  1. A1
  2. 1
  3. A3
  4. 2.3

4.7 Java 元组中的更多操作

所有元组类都有以下实用方法，例如集合，我们可以根据需要使用它们。

  • contains() – 如果该元组包含指定的元素，则返回true。
  • containsAll() – 如果该元组包含所有指定的元素，则返回true。
  • indexOf() – 返回指定元素首次出现的索引。
  • lastIndexOf() – 返回指定元素最后一次出现的索引。

元组还提供hashCode()，equals()和compareTo()方法的通用实现，这些方法可以很好地处理包装程序和字符串类。

5. Java 元组 - 总结

在此 Java 元组教程中，我们了解了如何通过javatuple库在 Java 中使用元组。 因此，如果您对存储固定数量的异构元素的数据结构有任何要求，则可以使用此库。 它非常简单，易于使用并提供良好的性能。

下载源码

学习愉快！

参考文献：

Javatuples的官方页面