JavaSE8有对还是元组？

我正在Java SE 8中玩弄惰性函数操作，我想

将索引
I
映射到成对/元组
（I，值[I]）
，然后基于第二个
值[I]
元素
过滤
，最后只输出索引

我还必须忍受这样的痛苦：在大胆的新纪元的兰博达斯和溪流

更新：我给出了一个相当简单的示例，其中@dkatzel在下面的一个答案中提供了一个简洁的解决方案。然而，它并不是一概而论。因此，让我添加一个更一般的示例：

package com.example.test;

import java.util.ArrayList;
import java.util.stream.IntStream;

public class Main {

  public static void main(String[] args) {
    boolean [][] directed_acyclic_graph = new boolean[][]{
        {false,  true, false,  true, false,  true},
        {false, false, false,  true, false,  true},
        {false, false, false,  true, false,  true},
        {false, false, false, false, false,  true},
        {false, false, false, false, false,  true},
        {false, false, false, false, false, false}
    };

    System.out.println(
        IntStream.range(0, directed_acyclic_graph.length)
        .parallel()
        .mapToLong(i -> IntStream.range(0, directed_acyclic_graph[i].length)
            .filter(j -> directed_acyclic_graph[j][i])
            .count()
        )
        .filter(n -> n == 0)
        .collect(() -> new ArrayList<Long>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
    );
  }

}

package com.example.test；
导入java.util.ArrayList；
导入java.util.stream.IntStream；
公共班机{
公共静态void main（字符串[]args）{
布尔[][]有向无环图=新布尔[][]{
{假，真，假，真，假，真}，
{假，假，假，真，假，真}，
{假，假，假，真，假，真}，
{假，假，假，假，假，真}，
{假，假，假，假，假，真}，
{假，假，假，假，假，假，假}
};
System.out.println(
IntStream.range（0，有向无环图.length）
.parallel（）
.mapToLong（i->IntStream.range（0，有向无环图[i].length）
.filter（j->有向无环图[j][i]）
.count（）
)
.filter（n->n==0）
.collect（（）->newarraylist（），（c，e）->c.add（e），（c1，c2）->c1.addAll（c2））
);
}
}

这将给出不正确的
[0，0，0]
输出，该输出对应于三列的计数，这三列均
为假
。我需要的是这三列的索引。正确的输出应该是
[0,2,4]
。我怎样才能得到这个结果呢？
遗憾的是，Java8没有引入成对或元组。当然，您可以随时使用（我个人确实与Java8结合使用），也可以创建自己的包装器。或者使用地图。或者诸如此类的东西，正如你链接到的问题的答案中所解释的


更新：JDK 14作为预览功能引入。这些不是元组，但可以用来保存许多相同的问题。在上面的具体示例中，这可能类似于：

public类jdk14示例{
记录CountForIndex（整数索引，长计数）{
公共静态void main（字符串[]args）{
布尔[][]有向无环图=新布尔[][]{
{假，真，假，真，假，真}，
{假，假，假，真，假，真}，
{假，假，假，真，假，真}，
{假，假，假，假，假，真}，
{假，假，假，假，假，真}，
{假，假，假，假，假，假，假}
};
System.out.println(
IntStream.range（0，有向无环图.length）
.parallel（）
.mapToObj（i->{
long count=IntStream.range（0，有向无环图[i]。长度）
.filter（j->有向无环图[j][i]）
.count（）；
返回新的CountForIndex（i，count）；
}
)
.filter（n->n.count==0）
.collect（（）->newarraylist（），（c，e）->c.add（e），（c1，c2）->c1.addAll（c2））
);
}
}

当使用
--enable preview
标志编译并运行时（在编写本文时，这是一个早期访问构建），您会得到以下结果：

[CountForIndex[index=0, count=0], CountForIndex[index=2, count=0], CountForIndex[index=4, count=0]]

因为您只关心索引，所以根本不需要映射到元组。为什么不编写一个过滤器来使用数组中的查找元素呢

     int[] value =  ...


IntStream.range(0, value.length)
            .filter(i -> value[i] > 30)  //or whatever filter you want
            .forEach(i -> System.out.println(i));

更新：这个答案是对原始问题的回答，JavaSE8有对还是元组？（如果不是的话，为什么不呢？）OP用一个更完整的例子更新了这个问题，但似乎不需要使用任何类型的配对结构就可以解决它。[操作说明：这里是。]


简而言之，答案是否定的。你要么自己动手，要么引入几个实现它的库中的一个

建议在JavaSE中使用
对
类，但至少被拒绝了一次。请参阅其中一个OpenJDK邮件列表上的。权衡并不明显。一方面，在其他库和应用程序代码中有许多Pair实现。这表明了一种需求，将此类类添加到JavaSE将增加重用和共享。另一方面，拥有一个Pair类增加了从Pair和Collection中创建复杂数据结构的诱惑，而无需创建必要的类型和抽象。（这是对该线程的一种解释。）

我建议每个人都阅读这整封邮件。它非常有洞察力，没有浮华。这很有说服力。当它开始时，我想，“是的，在JavaSE中应该有一个Pair类”，但当线程结束时，我改变了主意

但是请注意，JavaFX有这个类。JavaFX的api与javaseapi是分开发展的

正如我们可以从链接的问题中看到的那样，围绕着如此简单的API，存在着相当大的设计空间。对象应该是不可变的吗？它们应该是可序列化的吗？它们应该具有可比性吗？这门课是否应该是期末考试？这两个元素是否应该排序？它应该是一个接口还是一个类？为什么停在巴黎？为什么不是三元组、四元组或N元组

当然，这些元素不可避免地会被命名为bikeshed：


（a、b）
（第一，第二）
（左，右）
（汽车，cdr）
（富，巴）
等等

一个大问题几乎没有得到解决
Pair
ObjIntPair
ObjLongPair
ObjDoublePair
IntObjPair
IntIntPair
IntLongPair
IntDoublePair
LongObjPair
LongIntPair
LongLongPair
LongDoublePair
DoubleObjPair
DoubleIntPair
DoubleLongPair
DoubleDoublePair

    System.out.println(
        IntStream.range(0, acyclic_graph.length)
            .filter(i -> IntStream.range(0, acyclic_graph.length)
                                  .noneMatch(j -> acyclic_graph[j][i]))
            .boxed()
            .collect(toList()));

Tuple2<Integer, String> entry = Tuple.of(1, "A");

Integer key = entry._1;
String value = entry._2;

IntList list = IntLists.mutable.withAll(intStream);

Entry<Integer, String> pair = Map.entry(1, "a");