Java 元组介绍

原文：https://www.studytonight.com/java-examples/introduction-to-java-tuples

元组是一种数据结构，它像数组或列表一样以有序序列存储数据。但是与数组或列表不同，元组可以存储不同类型的数据。

例如，我们可以在元组中存储[“string”，123，123.321，' c']但不能使用数组或列表来存储。使用数组或列表实现这一点的唯一方法是创建一个字符串数组，并使用字符串存储它们，但这可能非常麻烦。

String[] arr = {"string", "123", "123.321", "c"};

我们还可以用所需类型的数据成员创建自己的类，这也会导致混乱和延迟。

Java 不提供任何实现元组的数据结构或集合，但是我们可以将名为 Java 元组的外部库添加到我们的项目中来使用它的元组类。这是一个简单明了的库，提供了不同的方法来处理元组。

Java 元组库

Java 元组库提供了十个不同的类，可以用来处理元组。这些类之间的区别在于可以存储在其中的元素数量。我们不能在一个 Java 元组类中存储超过 10 个元素。这些类的名称如下。

单元< A > 存储一个单元素。
配对< A、B > 储存两个元素。
三元组< A、B、C > 储存三个元素。
四方< A、B、C、D > 储存四元素。
五重奏< A、B、C、D、E > 储存五个元素。
六位< A、B、C、D、E、F > 储存六个元素。
九月< A、B、C、D、E、F、G > 储存七个元素。
八位字节< A、B、C、D、E、F、G、H > 存储八个元素。
Ennead < A、B、C、D、E、F、G、H、I > 储存九个元素。
十年< A、B、C、D、E、F、G、H、I、J > 储存十个元素。

我们还有两个类叫做键值< A，B > 和标签值< A，B > 。这些类似于配对< A、B >类。字母 A、B、C 等表示要存储在元组中的不同元素的数据类型。

这个库的所有元组类都是类型安全和不可变。我们不能在创建对象后更改数据或元组的结构。所有这些类都实现了可迭代、可序列化和可比较接口。

在 Java 中创建元组

创建元组非常简单。我们只需要向类构造器指定元素的数据类型及其值。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, Double, Integer> tuple1 = new Triplet<String, Double, Integer>("Str", 5.0, 5);
        System.out.println(tuple1);
    }
}

【Str，5.0，5】

我们也可以使用和()方法来创建一个新的元组。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, Double, Integer> tuple2 = Triplet.with("Str", 5.0, 5);
        System.out.println(tuple2);
    }
}

【Str，5.0，5】

我们也可以使用 fromCollection() 和 fromIterable() 方法从集合中创建一个新的元组。使用 fromCollection()时，请确保根据集合的大小使用正确的元组类。fromIterable()方法可以用来创建一个较小大小的元组，方法是指定应该从其中挑选元素的索引。

import java.util.Arrays;
import java.util.List;
import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        List<String> list = Arrays.asList("unit","pair", "triplet");
        Triplet<String, String, String> tuple1 = Triplet.fromCollection(list);
        System.out.println(tuple1);

        Pair<String, String> tuple2 = Pair.fromIterable(list, 1);//two elements to be fetched from index 1
        System.out.println(tuple2);
    }
}

【单位、对、三元组】【对、三元组】

在 Java 中获取元组的值

我们可以使用 getValue(X) 或 getValueX() 方法来获取元组中索引 X 处的元素。就像数组一样，元组也遵循零基索引。注意 getValue()方法不是类型安全的。使用这种方法时，我们需要使用铸造。但是 getValueX()方法是类型安全的，不需要铸造。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, Integer, Double> tuple = Triplet.with("Str", 5, 5.0);
        Integer i = (Integer)tuple.getValue(1);//casting
        Integer j = tuple.getValue1();

        System.out.println("Value fetched by getValue(): " + i);
        System.out.println("Value fetched by getValueX(): " + j);
    }
}

getValue()获取的值:5 getValueX()获取的值:5

在 Java 中设置元组的值

我们可以通过使用 setAtX() 方法来改变元组中元素的值，其中 X 是索引。这将返回与原始元组相同类的元组。由于元组是不可变的，所以原始元组不会以任何方式改变。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, Integer, Double> tuple1 = Triplet.with("Str", 5, 5.0);
        Triplet<String, Integer, Double> tuple2 = tuple1.setAt2(5.1);

        System.out.println("Original Tuple: " + tuple1);
        System.out.println("New Tuple with changes: " + tuple2);
    }
}

原始元组:[Str，5，5.0] 有变化的新元组:[Str，5，5.1]

在元组中添加元素

我们可以向现有的元组添加值，但是我们需要创建一个更大的新元组来容纳新元素。

例如，如果我们向 Septet 类元组添加一个元素，那么我们将得到一个 Octet 元组。

我们可以使用 add() 方法在元组的末尾添加一个元素。或者我们可以使用 addAtX() 方法在索引 x 处添加一个元素。这将把其他元素向右推一个位置。在插入新元素之前，请确保数据类型匹配。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, String, String> tuple1 = Triplet.with("str1", "str2", "str3");
        Quartet<String, String, String, String> tuple2 = tuple1.add("str4");
        Quartet<String, String, String, String> tuple3 = tuple1.addAt0("str0");

        System.out.println("Original Tuple: " + tuple1);
        System.out.println("Adding using add(): " + tuple2);
        System.out.println("Adding using addAtX(): " + tuple3);
    }
}

原始元组:[str1，str2，str3] 使用 add(): [str1，str2，str3，str4] 使用 addAtX(): [str0，str1，str2，str3]添加

这两种方法也可以用来将一个元组添加到另一个元组。我们需要小心新元组的最终大小。例如，如果一个配对类元组被添加到一个三元组类元组，则创建一个五元组元组。确保两个元组的组合大小不超过 10。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, String, String> tuple1 = Triplet.with("str1", "str2", "str3");
        Pair<String, String> tuple2 = Pair.with("str4", "str5");
        Quintet<String, String, String, String, String> tuple3 = tuple1.add(tuple2);
        Quintet<String, String, String, String, String> tuple4 = tuple1.addAt1(tuple2);

        System.out.println("Adding tuples using add(): " + tuple3);
        System.out.println("Adding tuples using addAtX(): " + tuple4);
    }
}

使用 add()添加元组:【str1、str2、str3、str4、str5】使用 addAtX()添加元组:【str1、str4、str 5、str2、str3】

移除元素

removeFromX() 方法可用于从索引 x 中移除元素。这将返回比原始数组小一个大小的元组。例如，当 removeFromX()用于四元组时，则返回一个三元组元组。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, String, String> tuple1 = Triplet.with("str1", "str2", "str3");
        Pair<String, String> tuple2 = tuple1.removeFrom0();
        Pair<String, String> tuple3 = tuple1.removeFrom1();

        System.out.println("Original Tuple: " + tuple1);
        System.out.println("Removing element at index 0: " + tuple2);
        System.out.println("Removing element at index 1: " + tuple3);
    }
}

原始元组:[str1，str2，str3] 移除索引 0 处的元素:[str2，str3] 移除索引 1 处的元素:[str1，str3]

循环/迭代元组

由于元组实现了可迭代接口，我们可以使用简单的 for-each 循环轻松地循环或迭代一个元组。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, String, String> tuple = Triplet.with("str1", "str2", "str3");

        for(Object o : tuple)
            System.out.print(o + " ");
    }
}

str1 str2 str3

Java 元组包含()和 containsAll()方法

顾名思义，contains()方法根据元组中元素的存在情况返回一个布尔值。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, String, String> tuple = Triplet.with("str1", "str2", "str3");    
        boolean containsStr1 = tuple.contains("Str1");
        boolean containsstr1 = tuple.contains("str1");

        System.out.println("Tuple contains Str1: " + containsStr1);
        System.out.println("Tuple contains str1: " + containsstr1);
    }
}

元组包含 Str1:假元组包含 str1:真

containsAll()方法可用于检查元组中是否存在集合的所有元素。这个方法也返回一个布尔值。

import java.util.Arrays;
import java.util.List;
import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Triplet<String, String, String> tuple = Triplet.with("str1", "str2", "str3");
        List<String> list1 = Arrays.asList("str1", "str3", "str2");
        List<String> list2 = Arrays.asList("str1", "str5", "str2");

        System.out.println("Tuple contains list1: " + tuple.containsAll(list1));
        System.out.println("Tuple contains list2: " + tuple.containsAll(list2));
    }
}

元组包含列表 1:真元组包含列表 2:假

Java 元组 indexOf()和 lastIndexOf()方法

indexOf()方法返回元组中第一个元素的索引。

方法返回元组中元素最后一次出现的索引。

import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Quartet<String, String, String, String> tuple = Quartet.with("str1", "str2", "str1", "str3");

        System.out.println("Tuple: " + tuple);
        System.out.println("First index of str1:" + tuple.indexOf("str1"));
        System.out.println("Last index of str1: " + tuple.lastIndexOf("str1"));
    }
}

元组:【str1，str2，str1，str 3】 str 1 的第一个索引:0 str 1 的最后一个索引:2

将元组转换为数组或列表

我们可以使用 toArray() 方法轻松地将元组转换为数组。同样，我们可以使用 toList() 方法将元组转换为列表。注意这两个方法将返回对象类型的数组和列表(对象[] arr，列表<对象>列表)，即使元组的所有元素具有相同的数据类型。

import java.util.Arrays;
import java.util.List;
import org.javatuples.*;

public class TupleDemo
{
    public static void main(String[] args)
    {
        Quartet<String, String, String, String> tuple = Quartet.with("str1", "str2", "str1", "str3");
        Object[] arrFromTuple = tuple.toArray();
        List<Object> listFromTuple = tuple.toList();

        System.out.println("Tuple: " + tuple);
        System.out.println("Array: " + Arrays.toString(arrFromTuple));
        System.out.println("List: " + listFromTuple);
    }
}

元组:[str1，str2，str1，str3] 数组:[str1，str2，str1，str3] 列表:[str1，str2，str1，str3]

常见问题

问:在 Java 中使用类如何实现元组？

元组的大小是固定的，用于将不同类型的数据存储在一起。例如，如果我们想要存储一个字符串、一个整数和一个双数，那么我们可以用这三个数据成员创建一个类，并编写适当的构造器来创建一个这种类型的新对象。但是最好使用像 Java 元组这样的外部库。

问:元组比列表快吗？

是的，元组比列表更快，因为它们的大小是固定的，并且是不可变的，所以我们可以只给它们分配一块内存，而不需要为额外的元素添加额外的空间。与列表相比，遍历元组也更快。

摘要

如果我们只希望分配一次数据，而不想再次更改该数据，元组是一种重要的数据结构。它们可以用来存储包含不同数据类型字段的记录，如[101，“巧克力”，5.99]。Java 元组库提供了不同的类，可以用来处理元组。元组类最多可以存储 10 个元素。关于元组需要注意的一点是，当我们设置、添加或移除值时，我们并没有改变原始元组，而是用修改创建了一个新的元组。这是因为元组是不可变的。