七爪源码:如何在 Java 中实现元组

在java中创建自定义元组数据类型

介绍

• 元组是一种旨在存储异构对象的数据结构。
• 当我们想要存储或返回异构对象（例如包含姓名、年龄、薪水等的 Customer 对象）时，它很有用。
• 在 Java 中，我们没有 SDK 提供的开箱即用的元组数据结构，但我们可以使用 Collection，如数组或 ArrayList。
• 我们还可以创建自己的 Tuple 类来提供这些功能。
• 除此之外，我们还有一些支持在 java 中创建元组的库。

用例

• 假设我们要创建存储 name 、 age 的客户对象。
  name 是字符串，而 age 是整数。
• 现在在 java 中，如果我们想存储这些异构数据，那么在 Java 中我们几乎没有选择。 让我们 - 探索。

使用列表作为元组

• 我们通常存储列表来存储特定的数据类型，例如整数、字符串甚至自定义类型。
• 但是我们也可以将对象数据类型存储在 List 中，尽管不推荐这样做，并且可能导致软件产生错误。这就是为什么在 java 中引入泛型以对 Collection 进行编译时检查，以便开发人员定义他们想要存储的数据类型。

        String userName = "Sam";
        Integer age =23;

        List customer = Arrays.asList(userName,age);

        System.out.println("customer name : "+customer.get(0));
        System.out.println("customer age : "+customer.get(1));

• 正如我们所见，我们将客户创建为列表并存储异构数据类型，但不建议这样做以避免代码中的错误。

实现自定义元组类

• 我们还可以创建我们的自定义元组实现。

一对

• 让我们实现 2 个元素的元组。 为了我们必须使用泛型来存储任何类型的元素。

• 尽管我们的元组在设计上是不可变的，但我们也可以创建可变元组。

import java.io.Serializable;

public class Tuple2<T,U> implements Serializable {
    private static final long serialVersionUID = -2344986941139471507L;

    private final T val1;
    private final U val2;

    public Tuple2(final T val1, final U val2) {
        this.val1 = val1;
        this.val2 = val2;
    }

    public static <T,U> Tuple2 of(final T val1, final U val2){
        return new Tuple2(val1,val2);
    }

    public T getVal1() {
        return val1;
    }

    public U getVal2() {
        return val2;
    }

    @Override
    public String toString() {
        return "Pair{" +
                "val1=" + val1 +
                ", val2=" + val2 +
                '}';
    }
}

三胞胎

• 类似地，我们可以扩展 2 个元素的元组想法来实现 3 或 4 的元组，依此类推。

import java.io.Serializable;

public class Tuple3<T,U,V> implements Serializable {

    private static final long serialVersionUID = -5193340612637235968L;
    private final T val1;
    private final U val2;
    private final V val3;

    public Tuple3(final T val1, final U val2, final V val3) {
        this.val1 = val1;
        this.val2 = val2;
        this.val3 = val3;
    }

    public static <T,U> Tuple3 of(final T val1, final U val2, final U val3){
        return new Tuple3(val1,val2,val3);
    }

    public T getVal1() {
        return val1;
    }

    public U getVal2() {
        return val2;
    }

    public V getVal3() {
        return val3;
    }

    @Override
    public String toString() {
        return "Tuple3{" +
                "val1=" + val1 +
                ", val2=" + val2 +
                ", val3=" + val3 +
                '}';
    }
}

客户代码

• 一旦我们的元组实现准备就绪，我们就可以使用我们的客户端代码。
• 请注意，我们的实现是不可变的，因此我们只能使用构造函数或使用工厂方法来创建实例来初始化元组。 我们没有设置器来初始化元组。

    public static void main(String[] args) {

        // setup tuple
        Tuple2<String,Integer> pair = new Tuple2<>("Sam Lee", 23);

        // get tuple
        System.out.println(pair.getVal1());

        // setup tuple
        Tuple2<Integer, String> pair1 = Tuple2.of(10, "Done");
        System.out.println(pair1.getVal1());

        // setup tuple
        Tuple3<String,Integer,Integer> triplet = new Tuple3<>("Sam Lee", 23, 123);
        System.out.println(triplet.toString());

    }

使用库

• 我们也可以使用库来创建 tuple 。 图书馆很少，例如
  - Apache Commons 朗
  - Java元组
• 让我们使用 Apache Commons Lang 来实现 2 个元素的元组。
  由于它是第三方库，我们需要使用 maven 或 gradle 导入它。

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
    </dependencies>

• 我们可以使用 apache commons 实现 immutablePair 和 mutablePair 来创建 2 个元素的元组
• 在 mutablePair 的情况下，我们可以修改我们的元组。

        ImmutablePair<String, Integer> customer = ImmutablePair.of("Sam", 23);
        System.out.println(customer.toString());

        MutablePair<String, Integer> customer = MutablePair.of("Sam", 23);
        System.out.println(customer.toString());
        customer.setRight(30);
        System.out.println(customer.toString());

为什么 Java 没有内置元组？

• 这样做的原因不是很清楚，但支持它的一个论点是 java 更注重可读性，因此与其使用诸如 tuple 之类的通用容器来存储元素，不如为该对象本身创建 Class 会很好。
• 在我们的示例中，我们可以为客户创建特定的类，而不是将其存储在元组中。
• 这将使我们的代码更具可读性，因为对象的类型将是清晰的，而不是通用元组。
• 但是作为开发人员，我们有很多选择来解决存储异构数据类型的问题。

结论

• 在本文中，我们讨论了在 java 中存储异构数据类型的不同方法。
• 我们可以自定义实现 tuple ，使用第三方库，如 javatuple ，甚至我们可以创建自定义类。

关注七爪网，获取更多APP/小程序/网站源码资源！