Java笛卡尔积实现

现实场景:将相同对象数据集内容进行生成出所有不重复的结构数据。

笛卡尔积是指两个集合中所有可能的有序对的集合。在Java中，我们可以通过多种方式实现笛卡尔积的计算。

1. 使用嵌套循环实现

这是最基本的方法，适用于两个集合的笛卡尔积计算。

java
import java.util.ArrayList;
import java.util.List;

public class CartesianProduct {
    public static <A, B> List<Pair<A, B>> cartesianProduct(List<A> listA, List<B> listB) {
        List<Pair<A, B>> result = new ArrayList<>();
        for (A a : listA) {
            for (B b : listB) {
                result.add(new Pair<>(a, b));
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> list1 = List.of(1, 2);
        List<String> list2 = List.of("A", "B", "C");
        
        List<Pair<Integer, String>> product = cartesianProduct(list1, list2);
        
        product.forEach(p -> System.out.println(p.getFirst() + ", " + p.getSecond()));
    }
}

class Pair<A, B> {
    private final A first;
    private final B second;
    
    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
    
    public A getFirst() { return first; }
    public B getSecond() { return second; }
}

2. 使用Java 8 Stream实现

Java 8的Stream API提供了更简洁的实现方式：

java
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CartesianProduct {
    public static <A, B> List<Pair<A, B>> cartesianProduct(List<A> listA, List<B> listB) {
        return listA.stream()
                .flatMap(a -> listB.stream()
                        .map(b -> new Pair<>(a, b)))
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<Integer> list1 = List.of(1, 2);
        List<String> list2 = List.of("A", "B", "C");
        
        List<Pair<Integer, String>> product = cartesianProduct(list1, list2);
        
        product.forEach(p -> System.out.println(p.getFirst() + ", " + p.getSecond()));
    }
}

3. 多个集合的笛卡尔积

对于多个集合的笛卡尔积，可以使用递归或Stream的reduce操作：

java
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CartesianProduct {
    public static <T> List<List<T>> cartesianProduct(List<List<T>> lists) {
        if (lists.isEmpty()) {
            return Collections.singletonList(Collections.emptyList());
        }
        
        return lists.stream()
                .reduce((list1, list2) -> list1.stream()
                        .flatMap(e1 -> list2.stream()
                                .map(e2 -> Stream.concat(e1.stream(), Stream.of(e2))
                                .collect(Collectors.toList()))
                        .collect(Collectors.toList()))
                .orElse(Collections.emptyList());
    }

    public static void main(String[] args) {
        List<List<String>> lists = List.of(
                List.of("A", "B"),
                List.of("1", "2"),
                List.of("X", "Y")
        );
        
        List<List<String>> product = cartesianProduct(lists);
        
        product.forEach(System.out::println);
    }
}

4. 使用Guava库

Google的Guava库提供了现成的笛卡尔积工具：

java
import com.google.common.collect.Lists;
import java.util.List;

public class CartesianProduct {
    public static void main(String[] args) {
        List<Integer> list1 = List.of(1, 2);
        List<String> list2 = List.of("A", "B", "C");
        
        List<List<Object>> product = Lists.cartesianProduct(list1, list2);
        
        product.forEach(System.out::println);
    }
}

注意事项

1. 笛卡尔积的计算复杂度是O(n*m)，对于大集合可能会导致内存问题
2. 对于多个集合的笛卡尔积，复杂度会指数级增长
3. 考虑使用惰性求值（如Stream）来处理大数据集

以上方法可以根据具体需求选择使用，简单场景使用嵌套循环即可，复杂场景可以考虑使用Stream或第三方库。