Java中如何实现支持可变数量泛型的Tuple？

Java本身不支持C++那种可变参数泛型（也就是无法直接定义Tuple<T...>这种任意长度的泛型类型），但可以通过以下几种方式模拟类似的使用体验，同时保证类型安全：

1. 预定义不同长度的泛型Tuple类+静态工厂方法（推荐） #

核心思路是为常用的Tuple长度（二元、三元、四元等）定义泛型内部类，再通过重载的静态of方法简化创建过程，调用时编译器会自动推断泛型类型，不用显式硬编码。

代码实现 #

public class Tuple {
    // 私有构造，禁止直接实例化外部类
    private Tuple() {}

    // 二元Tuple创建方法
    public static <A, B> Tuple2<A, B> of(A a, B b) {
        return new Tuple2<>(a, b);
    }

    // 三元Tuple创建方法
    public static <A, B, C> Tuple3<A, B, C> of(A a, B b, C c) {
        return new Tuple3<>(a, b, c);
    }

    // 四元Tuple创建方法，可按需扩展更多长度
    public static <A, B, C, D> Tuple4<A, B, C, D> of(A a, B b, C c, D d) {
        return new Tuple4<>(a, b, c, d);
    }

    // 二元Tuple内部类，不可变设计
    public static class Tuple2<A, B> {
        public final A first;
        public final B second;

        private Tuple2(A first, B second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public String toString() {
            return "(" + first + ", " + second + ")";
        }
    }

    // 三元Tuple内部类
    public static class Tuple3<A, B, C> {
        public final A first;
        public final B second;
        public final C third;

        private Tuple3(A first, B second, C third) {
            this.first = first;
            this.second = second;
            this.third = third;
        }

        @Override
        public String toString() {
            return "(" + first + ", " + second + ", " + third + ")";
        }
    }

    // 四元Tuple内部类
    public static class Tuple4<A, B, C, D> {
        public final A first;
        public final B second;
        public final C third;
        public final D fourth;

        private Tuple4(A first, B second, C third, D fourth) {
            this.first = first;
            this.second = second;
            this.third = third;
            this.fourth = fourth;
        }

        @Override
        public String toString() {
            return "(" + first + ", " + second + ", " + third + ", " + fourth + ")";
        }
    }
}

使用示例 #

// 编译器自动推断泛型，无需显式声明Tuple2<Integer, String>
var twoElement = Tuple.of(10, "Hello");
var threeElement = Tuple.of(20, 3.14, "World");
var fourElement = Tuple.of(true, 'X', 99, new Object());

System.out.println(twoElement);   // 输出：(10, Hello)
System.out.println(threeElement); // 输出：(20, 3.14, World)

2. 基于Object数组的非类型安全实现（不推荐） #

如果不在乎编译时类型检查，可以用Object[]存储元素，实现任意长度的Tuple，但取出元素时需要强制类型转换，容易引发运行时异常。

代码实现 #

import java.util.Arrays;

public class UnsafeTuple {
    private final Object[] elements;

    private UnsafeTuple(Object... elements) {
        this.elements = elements.clone();
    }

    public static UnsafeTuple of(Object... elements) {
        return new UnsafeTuple(elements);
    }

    @SuppressWarnings("unchecked")
    public <T> T get(int index) {
        return (T) elements[index];
    }

    @Override
    public String toString() {
        return Arrays.toString(elements);
    }
}

使用示例 #

UnsafeTuple tuple = UnsafeTuple.of(1, "Test", 3.14);
int num = tuple.get(0);       // 强制转换，编译无检查
String str = tuple.get(1);
double pi = tuple.get(2);

3. 借助第三方库 #

很多常用Java库已经封装了Tuple实现，比如Guava提供了Pair（二元）、Triple（三元）类，也可以通过其集合类模拟更长的Tuple，本质和第一种方式一致，只是不用自己重复造轮子。

内容的提问来源于stack exchange，提问作者Francis Godinho