笛卡尔积是指两个集合的所有可能的组合,即对于集合A和集合B,将集合A中的每个元素与集合B中的每个元素进行配对,得到一个新的集合。
在Java中,可以使用嵌套循环来实现笛卡尔积的计算。以下是一个示例代码:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class CartesianProduct {
public static void main(String[] args) {
List<List<String>> lists = new ArrayList<>();
lists.add(Arrays.asList("A", "B", "C"));
lists.add(Arrays.asList("1", "2", "3"));
lists.add(Arrays.asList("X", "Y", "Z"));
List<List<String>> cartesianProduct = getCartesianProduct(lists);
System.out.println(cartesianProduct);
}
public static List<List<String>> getCartesianProduct(List<List<String>> lists) {
List<List<String>> result = new ArrayList<>();
if (lists == null || lists.isEmpty()) {
return result;
}
int totalSize = 1;
for (List<String> list : lists) {
totalSize *= list.size();
}
for (int i = 0; i< totalSize; i++) {
List<String> combination = new ArrayList<>();
for (int j = 0; j< lists.size(); j++) {
int index = (i / getCombinationSize(lists, j)) % lists.get(j).size();
combination.add(lists.get(j).get(index));
}
result.add(combination);
}
return result;
}
private static int getCombinationSize(List<List<String>> lists, int index) {
int size = 1;
for (int i = index + 1; i< lists.size(); i++) {
size *= lists.get(i).size();
}
return size;
}
}
在上面的示例代码中,我们定义了一个CartesianProduct
类,其中包含了一个getCartesianProduct
方法,该方法接收一个List<List<String>>
类型的参数,表示要计算笛卡尔积的集合列表。该方法返回一个List<List<String>>
类型的结果,表示计算出的笛卡尔积。
在main
方法中,我们创建了一个包含三个元素的集合列表,分别是{"A", "B", "C"}
、{"1", "2", "3"}
和{"X", "Y", "Z"}
,然后调用getCartesianProduct
方法计算它们的笛卡尔积,并将结果输出到控制台。
输出结果如下:
[
[A, 1, X],
[A, 1, Y],
[A, 1, Z],
[A, 2, X],
[A, 2, Y],
[A, 2, Z],
[A, 3, X],
[A, 3, Y],
[A, 3, Z],
[B, 1, X],
[B, 1, Y],
[B, 1, Z],
[B, 2, X],
[B, 2, Y],
[B, 2, Z],
[B, 3, X],
[B, 3, Y],
[B, 3, Z],
[C, 1, X],
[C, 1, Y],
[C, 1, Z],
[C, 2, X],
[C, 2, Y],
[C, 2, Z],
[C, 3, X],
[C, 3, Y],
[C, 3, Z]
]
可以看到,计算出的笛卡尔积包含了所有可能的组合,共计27个组合。
领取专属 10元无门槛券
手把手带您无忧上云