我敢打赌你一定没用过 Java 中的这个类！

2023-02-28

java key pair

在 Java 中有这样的一个类，平时可能都用不到，但是需要的时候还是会很方便的，它就是Java中的javafx.util.Pair。在介绍Pair的使用之前我们先看看下面的例子。如果对 Python 或者 GO 这两个语言有了解的，应该知道

在 Java 中有这样的一个类，平时可能都用不到，但是需要的时候还是会很方便的，它就是 Java 中的javafx.util.Pair。在介绍 Pair 的使用之前我们先看看下面的例子。

如果对 Python 或者 GO 这两个语言有了解的，应该知道这两种语言是有下面这样的特性，那就是一个函数可以返回多个值，如下所示：

Python 示例：

#! /usr/bin/env python3
# -*- 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)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

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)
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

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;
  }1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

这种做法确实可以，而且很多时候我们就是这么使用的，对于确定的类型我们可以使用确定类型的集合，对于不确定类型我们可以用 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;
  }1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

这里使用的 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);

  }1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

在抽象类 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>1.
2.
3.
4.
5.

其中各个数量的元组类名称如下，不得不说十元组的数量已经不算少了，一般这种情况还是使用实体来的方便：

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)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.