如何从列表中获取元素的组合，如图所示

Question

我有一个List<int[]> 作为index_position:int[] values

input:

index 0:{1,2} 
index 1:{1,3,5} 
index 2:{2}

无论是否使用 Lambda，我如何在 Java 中获得以下组合。

第一步：找出所有这样的组合

[{1,1,2}, {1,3,2}, {1,5,2}, {2,1,2}, {2,3,2}, {2,5,2}]

-> 

Step2：从已获得的组合中删除重复项

[{1,2}, {1,3,2}, {1,5,2}, {2,1}, {2,3}, {2,5}]

“想要在每个步骤中执行，例如从 n 个数组生成所有 n 个元素子集 >其中第一个元素来自第一个数组，第二个来自第二个数组...，>从每个结果子集中删除重复项。”

不需要进一步减少

[{1,2}, {1,2}] 

到

[{1,2}] 

或

[{1,2},{2,1}] 

到

[{1,2}] / [{2,1}]

但在我的情况下也不会影响结果。

Answer 1

您要问的似乎是 N 组的笛卡尔积 (Set1 x Set2 x ... x SetN)。

不幸的是，Java 中没有标准方法可以让我们轻松构建一个，但在 Guava 及其Sets.cartesianProduct 方法的帮助下，这项任务似乎很容易。

唯一的条件是我们需要提供List<Set<..>>作为它的参数。
因为这个答案是基于假设 每个 int[] 都可以被视为集合，这意味着它的值必须是唯一的。实际上更准确地说，如果index 0 将是{1,2,1} 或{1,2,2}，它将被处理为设置{1,2}。

这是List<Set<Integer>> 的示例，其中包含您当前的数据
（toList 是静态导入的Collections.toList() 方法，类似toSet）：

//part 0: preparing data
List<Set<Integer>> sets = new ArrayList<>(
            Arrays.asList(
                new HashSet<>(Arrays.asList(1, 2)), 
                new HashSet<>(Arrays.asList(1, 3, 5)),
                new HashSet<>(Arrays.asList(2))
            )
        );
sets.forEach(System.out::println);
System.out.println("-----------------");

//part 1: calculating cartesian products
Set<List<Integer>> cartesianProducts = Sets.cartesianProduct(sets);
System.out.println(cartesianProducts);
System.out.println("-----------------");

//part 2
List<List<Integer>> noDuplicatesInProducts = cartesianProducts
        .stream()//iterate over each cartesian product
        .map(product ->  product.stream()
                          .distinct()//remove duplicate values
                          .collect(toList())//store updated product as list
        ).collect(toList());//store all products as list
System.out.println(noDuplicatesInProducts);

输出：

[1, 2]
[1, 3, 5]
[2]
-----------------
[[1, 1, 2], [1, 3, 2], [1, 5, 2], [2, 1, 2], [2, 3, 2], [2, 5, 2]]
-----------------
[[1, 2], [1, 3, 2], [1, 5, 2], [2, 1], [2, 3], [2, 5]]

---

如果您正在寻找一种将List<int[]> 转换为List<Set<Integer>> 的方法，这里有一个示例：

private static List<Set<Integer>> convert(List<int[]> list) {
    return list
            .stream()
            .map(arr -> 
                    IntStream.of(arr)
                    .mapToObj(Integer::valueOf)// same as .boxed()
                    .collect(toSet())
            ).collect(toList());
}

Answer 2

编辑：当时给出了这个答案，问题含糊不清，并提出了“删除重复项”的问题。我会保留这个答案，因为它可能包含对其他人有用的信息。

由于您没有正确描述输入和想要的输出，因此很难说出问题的确切解决方案。仅发布一个示例是不够的。

所以我们假设如下：

• 输入：整数数组列表 (List<int[]>)。

• 输出：整数数组列表 (List<int[]>)，其中第 n 个 数组包含第 n 个值 输入列表的数组，但删除了重复项。

将输入列表的项目复制到一个新的输出列表中很简单：

List<int[]> output = new ArrayList<>(input.size());
for(int[] item : input) {
    output.add(removeDuplicates(item));
}

因此问题可以简化为从int[] 中删除重复项。这可以通过使用中间Set<Integer> 轻松解决，因为Set 默认情况下没有重复项。不幸的是，int[] 不能直接放入 HashSet<Integer> 中，反之亦然，因此我们必须手动复制元素：

public int[] removeDuplicates(int[] input) {
    Set<Integer> set = new HashSet<Integer>();
    for (int i = 0; i < input.length; i++)
        set.add(input[i]);
    int[] output = new int[set.size()];
    int i = 0;
    for (Integer e : set) {
        output[i++] = e;
    }
    return output;
}

（另见How to efficiently remove duplicates from an array without using Set）

当然，如果您可以将List<Collection<Integer>> 作为输入和输出，一切都会容易得多。在这种情况下，事情可以很容易地完成如下：

List<Collection<Integer>> output = new ArrayList<>(input.size());
for(Collection<Integer> item : input) {
    output.add(new HashSet<Integer>(item));
}

使用 Java 8 流式处理 API

为了完整性：Java 8 流式 API 让生活变得更加轻松，即使使用 List<int[]>：

List<int[]> output = input.stream()
    .map(item -> Arrays.stream(item).distinct().toArray())
    .collect(Collectors.toList());

Answer 3

我假设您想在不触及顺序的情况下从每个数组中删除重复项。

您可以将每个数组映射到例如LinkedHashSet，保持秩序但不允许重复。然后只需映射回int[] 并使用Collectors.toList() 收集：

list = list.stream()
    .map(a -> Arrays.stream(a).boxed().collect(Collectors.toList())) // map to List<Integer>
    .map(LinkedHashSet::new) // map to LinkedHashSet<Integer>
    .map(s -> s.stream().mapToInt(i -> i).toArray()) // map to int[]
    .collect(Collectors.toList());