在Java中使用Pairs或2元组

Using Pairs or 2-tuples in Java

本问题已经有最佳答案,请猛点这里访问。

Java中的Hashtable将受益于具有元组结构的值。 我可以在Java中使用哪种数据结构来做到这一点?

1
Hashtable<Long, Tuple<Set<Long>,Set<Long>>> table = ...


我不认为Java中有一个通用的元组类,但自定义元组可能就像下面这样简单:

1
2
3
4
5
6
7
8
public class Tuple<X, Y> {
  public final X x;
  public final Y y;
  public Tuple(X x, Y y) {
    this.x = x;
    this.y = y;
  }
}

当然,如何在平等性,不变性等方面进一步设计这个类有一些重要的含义,特别是如果你打算使用实例作为散列的键。


javatuples是Java中元组的专用项目。

1
2
3
Unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)


Apache Commons提供了一些常见的Java实用程序,包括一对。它实现了Map.EntryComparableSerializable


如果您正在寻找内置的Java双元素元组,请尝试AbstractMap.SimpleEntry


作为@maerics很好的答案的扩展,我添加了一些有用的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Tuple<X, Y> {
    public final X x;
    public final Y y;
    public Tuple(X x, Y y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return"(" + x +"," + y +")";
    }

    @Override
    public boolean equals(Object other) {
        if (other == this) {
            return true;
        }

        if (!(other instanceof Tuple)){
            return false;
        }

        Tuple<X,Y> other_ = (Tuple<X,Y>) other;

        // this may cause NPE if nulls are valid values for x or y. The logic may be improved to handle nulls properly, if needed.
        return other_.x.equals(this.x) && other_.y.equals(this.y);
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((x == null) ? 0 : x.hashCode());
        result = prime * result + ((y == null) ? 0 : y.hashCode());
        return result;
    }
}


另外2美分:从Java 7开始,现在标准Lib中有一个类:javafx.util.Pair。

是的,它是标准的Java,现在JavaFx包含在JDK中:)


这是其他地方的完全相同的问题,其中包括一个更强大的equalshash,其中maerics暗示:

http://groups.google.com/group/comp.lang.java.help/browse_thread/thread/f8b63fc645c1b487/1d94be050cfc249b

那个讨论继续反映了maerics和ColinD的方法"我应该重新使用一个具有非特定名称的类元组,或者在每次遇到这种情况时创建一个具有特定名称的新类"。多年前我在后一个营地;我已经发展成为支持前者。


使用lombok,很容易声明一个Pair类:

1
2
3
4
5
@Data(staticConstructor ="of")
public class Pair<A, B> {
    private final A left;
    private final B right;
}

这将生成名为"of",equals()hashcode()toString()的getter,静态构造函数。

有关更多信息,请参阅@Data文档


Android Tuple Utils

此对象提供equals()的合理实现,如果equals()在每个包含的对象上为true,则返回true。


创建一个类,描述您实际建模和使用它的概念。它可以只存储两个Set并为它们提供访问器,但是它应该被命名以指示每个集合究竟是什么以及为什么它们被组合在一起。


为了补充@ maerics的答案,这里是Comparable元组:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.*;

/**
 * A tuple of two classes that implement Comparable
 */

public class ComparableTuple<X extends Comparable<? super X>, Y extends Comparable<? super Y>>
       extends Tuple<X, Y>
       implements Comparable<ComparableTuple<X, Y>>
{
  public ComparableTuple(X x, Y y) {
    super(x, y);
  }

  /**
   * Implements lexicographic order
   */

  public int compareTo(ComparableTuple<X, Y> other) {
    int d = this.x.compareTo(other.x);
    if (d == 0)
      return this.y.compareTo(other.y);
    return d;
  }
}


虽然这篇文章已经很老了,虽然我知道我不是很有帮助,但我认为这里完成的工作是:http://www.pds.ewi.tudelft.nl/pubs/papers/cpe2005.pdf,在主流Java方面会很好。

你可以这样做:

1
2
3
4
int a;
char b;
float c;
[a,b,c] = [3,'a',2.33];

要么

1
[int,int,char] x = [1,2,'a'];

要么

1
2
3
4
5
6
7
public [int,boolean] Find(int i)
{
  int idx = FindInArray(A,i);
  return [idx,idx>=0];
}

[idx, found] = Find(7);

这里的元组是:

  • 定义为基本类型 - 没有模板/泛型
  • 堆栈分配,如果在本地声明
  • 使用模式匹配进行分配

这种方法增加了

  • 性能
  • 可读性
  • 表现


我将从关于Java中元组的一般观点开始,并以对您具体问题的含义完成。

1)在Java中避免使用非通用语言中的元组的方式,因为它们不是类型安全的(例如在Python中:tuple = (4, 7.9, 'python'))。如果您仍想使用通用元组(不推荐使用)之类的东西,则应使用Object[]List并在检查后使用instanceof转换元素以确保类型安全。

通常,某个设置中的元组总是以相同的方式使用,包含相同的结构。在Java中,您必须在class中显式定义此结构,以提供定义良好的类型安全值和方法。这看起来很烦人且不必要,但在编译时已经防止了错误。

2)如果需要包含相同(超级)类Foo的元组,请使用Foo[]ListList(或列表的不可变对应项)。由于元组不是定义的长度,因此该解决方案是等效的。

3)在你的情况下,你似乎需要一个Pair(即一个定义明确的长度为2的元组)。这使得maerics的答案或其中一个补充答案最有效,因为您可以在将来重用代码。


您可以使用Google Guava Table