使用Java Lambda创建两个（或更多）列表的笛卡尔乘积集合

在Scala中，我可以通过以下方式轻松实现这一点：

def permute(xs: List[Int], ys: List[Int]) = {
  for {x <- xs; y <- ys} yield (x,y)
}

def-permute（xs:List[Int]，ys:List[Int]）={
因为{x我很难弄清楚你想要什么，看起来你想得到一个笛卡尔积？比如，给定
{1,2}
和
{3,4}
，你期望
{（1,3）、（1,4）、（2,3）、（2,4）}
？（值得一提的是，我认为这与排列的数学定义没有任何关系，排列通常涉及对单个列表内容排序的不同方式。）

那是可以写的

xs.stream()
  .flatMap(x -> ys.stream().map(y -> Pair.of(x, y)))
  .collect(toList());

如果你想避免重复，那么你是在组合之后，而不是笛卡尔积之后

        List<Integer> xs = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
        List<Integer> ys = new ArrayList<>(Arrays.asList(3, 4, 5, 6, 7));

        List<String> combinations =
                xs.stream()
                .flatMap(
                        x -> ys.stream()
                        .filter( y -> x != y)
                        .map(y -> x + ":" + y)
                ).collect(Collectors.toList());
        System.out.println(combinations);

我来自未来。这就是我知道这一点的原因。=）
你完全理解我想要的东西。这个词似乎是错的。当我想要得到列表组合的数量从两个增加到三个以上时，嵌套似乎是不可避免的。这肯定比我之前所做的更干净。顺便说一句，这对来自OpenJFX/JavaFX，它在包n中您可以用AbstractMap.SimpleImmutableEntry替换它。
[1:3, 1:4, 1:5, 1:6, 1:7, 2:3, 2:4, 2:5, 2:6, 2:7, 3:4, 3:5, 3:6, 3:7, 4:3, 4:5, 4:6, 4:7, 5:3, 5:4, 5:6, 5:7, 6:3, 6:4, 6:5, 6:7, 7:3, 7:4, 7:5, 7:6]