遗憾的是，Java 8没有引入对或元组。当然，您总是可以使用org.apache.commons.lang3.tuple(我个人在与Java 8结合使用时使用它)，或者您可以创建自己的包装器。或者使用地图。或者类似的东西，就像你链接的那个问题的公认答案所解释的那样。

更新:JDK 14将记录类作为预览特性引入，JDK 16将它们作为标准语言特性引入。它们不是元组，但可以用来解决许多相同的问题。在上面的具体例子中，可能是这样的:

public class Jdk14Example {
    record CountForIndex(int index, long count) {}

    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()
                        .mapToObj(i -> {
                            long count = IntStream.range(0, directed_acyclic_graph[i].length)
                                            .filter(j -> directed_acyclic_graph[j][i])
                                            .count();
                            return new CountForIndex(i, count);
                        }
                        )
                        .filter(n -> n.count == 0)
                        .collect(() -> new ArrayList<CountForIndex>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
        );
    }
}

当使用——enable-preview标志或JDK 16或更高版本编译并运行JDK 14时，你会得到以下结果:

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

遗憾的是，Java 8没有引入对或元组。当然，您总是可以使用org.apache.commons.lang3.tuple(我个人在与Java 8结合使用时使用它)，或者您可以创建自己的包装器。或者使用地图。或者类似的东西，就像你链接的那个问题的公认答案所解释的那样。

更新:JDK 14将记录类作为预览特性引入，JDK 16将它们作为标准语言特性引入。它们不是元组，但可以用来解决许多相同的问题。在上面的具体例子中，可能是这样的:

public class Jdk14Example {
    record CountForIndex(int index, long count) {}

    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()
                        .mapToObj(i -> {
                            long count = IntStream.range(0, directed_acyclic_graph[i].length)
                                            .filter(j -> directed_acyclic_graph[j][i])
                                            .count();
                            return new CountForIndex(i, count);
                        }
                        )
                        .filter(n -> n.count == 0)
                        .collect(() -> new ArrayList<CountForIndex>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
        );
    }
}

当使用——enable-preview标志或JDK 16或更高版本编译并运行JDK 14时，你会得到以下结果:

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

Yes.

地图。条目可以作为Pair使用。

Unfortunately it does not help with Java 8 streams as the problem is that even though lambdas can take multiple arguments, the Java language only allows for returning a single value (object or primitive type). This implies that whenever you have a stream you end up with being passed a single object from the previous operation. This is a lack in the Java language, because if multiple return values was supported AND streams supported them we could have much nicer non-trivial tasks done by streams.

在那之前，它几乎没有什么用处。

Java 16带来了记录，这是解决这个问题和其他问题的一个很好的解决方案。一个非常强烈的理由瞄准即将到来的Java 17 LTS

Vavr(以前称为Javaslang) (http://www.vavr.io)也提供元组(til大小为8)。这是javadoc: https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple.html。

这是一个简单的例子:

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

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

为什么JDK本身直到现在还没有提供简单的元组，这对我来说是一个谜。编写包装器类似乎是一项日常工作。

许多第三方库支持元组。例如jOOλ，支持0到16度的元组，例如:

// Assuming this static import
import static org.jooq.lambda.tuple.Tuple.*;

// Write:
var t = tuple(1, "a", 2L);
Integer i = t.v1;
String s = t.v2;
Long l = t.v3;

其他也有元组的库，例如:

反应堆 Javatuples Apache Flink Vavr

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

     int[] value =  ...


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