在 Java 中有这样的一个类，平时可能都用不到，但是需要的时候还是会很方便的，它就是 Java 中的javafx.util.Pair。在介绍 Pair 的使用之前我们先看看下面的例子。
如果对 Python 或者 GO 这两个语言有了解的，应该知道这两种语言是有下面这样的特性，那就是一个函数可以返回多个值，如下所示：
Python 示例：
# -*- coding: utf-8 -*-
"""
日期：2022-07-09 12:14
描述：a test module
"""
__author__ = 'ziyou'
def mul_result(a, b):
key = "key"
value = a + b
return key, value
if __name__ == '__main__':
key, mul = mul_result(3, 4)
print(key)
print(mul)GO 示例：
package main
import "fmt"
func mul_result(a, b int) (key string, value int) {
key = "key"
value = a + b
return key, value
}
func main() {
key, value := mul_result(3, 4)
fmt.Println(key)
fmt.Println(value)
}mul_result 函数接收两个入参，并且同时也返回两个结果，在调用的地方可以直接获取到两个返回值。
那么在 Java 语言中能否实现这样的效果呢？
有的小伙伴就说了，那不是 so easy 吗？我可以定义一个实体类，想返回多少个字段就返回多少个字段，还有的小伙伴就说了，我可以利用集合不管是 List 还是 Map 都可以实现，如下所示：
public static void main(String[] args) {
Map<String, Object> result = mul_result(3, 4);
System.out.println(result.get("key"));
System.out.println(result.get("value"));
}
public static Map<String, Object> mul_result(int a, int b) {
Map<String, Object> result = new HashMap<>();
result.put("key", "key");
result.put("value", a + b);
return result;
}这种做法确实可以，而且很多时候我们就是这么使用的，对于确定的类型我们可以使用确定类型的集合，对于不确定类型我们可以用 Object 类型。不过当对于有时候只有两个固定的 key-value 需要返回的时候，我们就可以用一种更优雅的 Pair 形式来进行处理。
public static void main(String[] args) {
Pair<String, Integer> pair = testPair(3, 4);
System.out.println(pair.getKey());
System.out.println(pair.getValue());
}
public static Pair<String, Integer> testPair(int a, int b) {
Pair<String, Integer> pair = new Pair<>("key", a + b);
return pair;
}这里使用的 Pair 是 JDK 自带的类javafx.util.Pair，Pair 对象通过构造函数创建过后，是不能进行修改的，除了 Pair 之外，JDK 还有另外两个一样功能的类可以使用，如下所示：
public static void main(String[] args) {
AbstractMap.SimpleEntry<String, Integer> simpleEntry = new AbstractMap.SimpleEntry<>("Java极客技术", 666);
System.out.println(simpleEntry.getKey());
System.out.println(simpleEntry.getValue());
simpleEntry.setValue(6666);
AbstractMap.SimpleImmutableEntry<String, Integer> immutableEntry = new AbstractMap.SimpleImmutableEntry<>("Java极客技术", 666);
System.out.println(immutableEntry.getKey());
System.out.println(immutableEntry.getValue());
immutableEntry.setValue(6666);
}在抽象类 AbstractMap 中有 SimpleEntry 和 SimpleImmutableEntry 这两个子类也有同样的效果，另外从名字上我们也可以看出来 SimpleImmutableEntry 是不支持修改，如果进行了修改会报错 UnsupportedOperationException，上面的代码运行的效果如下：
Pair 类的使用场景主要就是在一些需要返回固定配对的地方，真正遇到的场景可能也不太多，所以大家在日常的工作中也并不常用，而且可替代的方案也有很多。
其实通过 JDK 的源码我们可以看到 Pair 的实现也特别简单，底层也就是包含两个字段 key，value 的实体类，跟我们自己写的没太大的区别，不过既然 JDK 已经给我提供的具体的实现为何不采用拿来主义呢？
写到这里有的小伙伴就要问了，那我要想返回一个三元组怎么办呢？Python 和 GO 我直接加一个返回值就行了，在 Java 这里不行了吧。确实JDK 本身并没有提供三元组的实现，如果真的需要我们可以使用 Pair 自己来构造一个三元组，不过这个世界上总有一些好事之者已经帮我们做好了。
Javatuples 是一个第三方的 Java 元组库，这个库目前实现了最多十个元组，如果要实现常用的三元组或者四元组可以使用这个组件，不过更多元组的使用场景并不多，而且也不是很灵活，还是乖乖自定义实体吧。
感兴趣的朋友可以自己试试这个组件，在 pom 文件中加入如下依赖：
<dependency>
<groupId>org.javatuples</groupId>
<artifactId>javatuples</artifactId>
<version>1.2</version>
</dependency>其中各个数量的元组类名称如下，不得不说十元组的数量已经不算少了，一般这种情况还是使用实体来的方便：
Unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)
Quartet<A,B,C,D> (4 elements)
Quintet<A,B,C,D,E> (5 elements)
Sextet<A,B,C,D,E,F> (6 elements)
Septet<A,B,C,D,E,F,G> (7 elements)
Octet<A,B,C,D,E,F,G,H> (8 elements)
Ennead<A,B,C,D,E,F,G,H,I> (9 elements)
Decade<A,B,C,D,E,F,G,H,I,J> (10 elements)
