Java-从多个数组中获取n个元素的组合

我有4种类型的整数值。我想从下面的数组中生成由3个元素组成的所有可能的组合，如

5 1 72
3 7 9
8 14 11 //etc

List<Integer> list1 = Arrays.asList(5, 7, 11, 2, 10);
List<Integer> list2 = Arrays.asList(1, 9, 25);
List<Integer> list3 = Arrays.asList(72, 8);
List<Integer> list4 = Arrays.asList(3, 14, 22, 37, 19);

如何获得3个元素的组合

private static List<List<Integer>> getCombination(int currentIndex, List<TempContainer<Integer>> containers) {
        if (currentIndex == containers.size()) {
            // Skip the items for the last container
            List<List<Integer>> combinations = new ArrayList<>();
            combinations.add(new ArrayList<>());
            return combinations;
        }
        List<List<Integer>> combinations = new ArrayList<>();
        TempContainer<Integer> container = containers.get(currentIndex);
        List<Integer> containerItemList = container.getItems();
        List<List<Integer>> suffixList = getCombination(currentIndex + 1, containers);
        int size = containerItemList.size();
        for (int ii = 0; ii < size; ii++) {
            Integer containerItem = containerItemList.get(ii);
            if (suffixList != null) {
                for (List<Integer> suffix : suffixList) {
                    List<Integer> nextCombination = new ArrayList<>();
                    nextCombination.add(containerItem);
                    nextCombination.addAll(suffix);
                    combinations.add(nextCombination);
                }
            }
        }
        return combinations;
    }

TempContainer container1 = new TempContainer();
        container1.setItems(list1);
        TempContainer container2 = new TempContainer();
        container2.setItems(list2);
        TempContainer container3 = new TempContainer();
        container3.setItems(list3);
        TempContainer container4 = new TempContainer();
        container4.setItems(list4);
        List<TempContainer<Integer>> containers = new ArrayList<>(3);
        containers.add(container1);
        containers.add(container2);
        containers.add(container3);
        containers.add(container4);
// Get combinations
        List<List<Integer>> combinations = getCombination(0, containers);

私有静态列表getCombination（int-currentIndex，列表容器）{
if（currentIndex==containers.size（））{
//跳过最后一个容器的项目
列表组合=新的ArrayList（）；
添加（新的ArrayList（））；
收益组合；
}
列表组合=新的ArrayList（）；
TempContainer=containers.get（currentIndex）；
List containerItemList=container.getItems（）；
列表后缀列表=getCombination（currentIndex+1，容器）；
int size=containerItemList.size（）；
用于（int ii=0；ii

基本上，你必须做你以前做过的事情。唯一的区别是，由于您现在只使用四个列表中的三个，因此必须添加第二个置换循环，循环遍历相关列表的所有可能组合。因此，算法是：

• 从四个列表中生成三个列表的所有可能组合
• 对于每个组合，使用前面的算法（用于生成所有可能的元素组合）

---

基本上，你必须做你以前做过的事情。唯一的区别是，由于您现在只使用四个列表中的三个，因此必须添加第二个置换循环，循环遍历相关列表的所有可能组合。因此，算法是：

• 从四个列表中生成三个列表的所有可能组合
• 对于每个组合，使用前面的算法（用于生成所有可能的元素组合）

---

我认为更好的解决方案是：

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(5, 7, 11, 2, 10);
    List<Integer> list2 = Arrays.asList(1, 9, 25);
    List<Integer> list3 = Arrays.asList(72, 8);
    List<Integer> list4 = Arrays.asList(3, 14, 22, 37, 19);

    List<Integer[]> combinations = getCombinations(list1, list2, list3, list4);
    for (Integer[] combination : combinations)
        System.out.println(combination[0] + "," + combination[1] + "," + combination[2]);
}

public static List<Integer[]> getCombinations(List<Integer>... lists) {
    return _getCombination(0, new ArrayList<>(), new ArrayList<>(), lists);
}

private static List<Integer[]> _getCombination(int depth, List<Integer[]> currentCombinations,
                                             List<Integer> currentCombination, List<Integer>... lists) {
    if (currentCombination.size() == 3) {
        currentCombinations.add(currentCombination.toArray(new Integer[3]));
    } else {
        for (int i = 0 ; i < lists.length ; i++)
            for (int j = 0 ; j < lists[i].size() ; j++) {
            currentCombination.add(lists[i].get(j));
            _getCombination(depth + 1, currentCombinations, currentCombination, lists);
            currentCombination.remove(lists[i].get(j));
        }
    }
    return currentCombinations;
}

publicstaticvoidmain（字符串[]args）{
list1=Arrays.asList（5,7,11,2,10）；
list2=Arrays.asList（1,9,25）；
list3=Arrays.asList（72,8）；
list4=Arrays.asList（3,14,22,37,19）；
列表组合=获取组合（列表1、列表2、列表3、列表4）；
对于（整数[]组合：组合）
System.out.println（组合[0]+“，“+组合[1]+”，“+组合[2]）；
}
公共静态列表组合（列表…列表）{
返回_getCombination（0，new ArrayList（），new ArrayList（），List）；
}
私有静态列表_getCombination（整数深度，列表当前组合，
列表当前组合，列表…列表）{
if（currentCombination.size（）==3）{
currentcombings.add（currentCombination.toArray（新整数[3]）；
}否则{
for（int i=0；i

我认为更好的解决方案是：

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(5, 7, 11, 2, 10);
    List<Integer> list2 = Arrays.asList(1, 9, 25);
    List<Integer> list3 = Arrays.asList(72, 8);
    List<Integer> list4 = Arrays.asList(3, 14, 22, 37, 19);

    List<Integer[]> combinations = getCombinations(list1, list2, list3, list4);
    for (Integer[] combination : combinations)
        System.out.println(combination[0] + "," + combination[1] + "," + combination[2]);
}

public static List<Integer[]> getCombinations(List<Integer>... lists) {
    return _getCombination(0, new ArrayList<>(), new ArrayList<>(), lists);
}

private static List<Integer[]> _getCombination(int depth, List<Integer[]> currentCombinations,
                                             List<Integer> currentCombination, List<Integer>... lists) {
    if (currentCombination.size() == 3) {
        currentCombinations.add(currentCombination.toArray(new Integer[3]));
    } else {
        for (int i = 0 ; i < lists.length ; i++)
            for (int j = 0 ; j < lists[i].size() ; j++) {
            currentCombination.add(lists[i].get(j));
            _getCombination(depth + 1, currentCombinations, currentCombination, lists);
            currentCombination.remove(lists[i].get(j));
        }
    }
    return currentCombinations;
}

publicstaticvoidmain（字符串[]args）{
list1=Arrays.asList（5,7,11,2,10）；
list2=Arrays.asList（1,9,25）；
list3=Arrays.asList（72,8）；
list4=Arrays.asList（3,14,22,37,19）；
列表组合=获取组合（列表1、列表2、列表3、列表4）；
对于（整数[]组合：组合）
System.out.println（组合[0]+“，“+组合[1]+”，“+组合[2]）；
}
公共静态列表组合（列表…列表）{
返回_getCombination（0，new ArrayList（），new ArrayList（），List）；
}
私有静态列表_getCombination（整数深度，列表当前组合，
列表当前组合，列表…列表）{
if（currentCombination.size（）==3）{
currentcombings.add（currentCombination.toArray（新整数[3]）；
}否则{
for（int i=0；i

尝试类似的方法

    List<Integer> list1 = Arrays.asList(72, 8);
    List<Integer> list2 = Arrays.asList(1,  9, 25);
    List<Integer> list3 = Arrays.asList(5,  7, 11,  2, 10);
    List<Integer> list4 = Arrays.asList(3,  14,22, 37, 19, 18);
    List<List<Integer>> mainList = new ArrayList<>();
    mainList.add(list4);
    mainList.add(list3);
    mainList.add(list2);
    mainList.add(list1);
    int max = 0;
    // FIND MAX LIST So that We can ITERATE on that 
    for (int k = 0; k < mainList.size(); k++) {
        if (mainList.get(k).size() > max) {
            max = mainList.get(k).size();
        }
    }

    for (int k = 0; k < max; k++) {
        String string = new String(); // You can use another list of array to store combination. For testing I have used String
        try {
            for (int l = 0; l < mainList.size(); l++) {
                if (mainList.get(l).size() > k)
                    string = string.concat(" " + mainList.get(l).get(k));
            }

            System.out.println(string);
        } catch (Exception e) {
            System.out.println("Error IN CALL");
        }
    }

list1=Arrays.asList（72,8）；
list2=Arrays.asList（1,9,25）；
list3=Arrays.asList（5,7,11,2,10）；
list4=Arrays.asList（3,14,22,37,19,18）；
List mainList=new ArrayList（）；
mainList.add（列表4）；
mainList.add（列表3）；
mainList.add（列表2）；
mainList.add（列表1）；
int max=0；
//查找最大列表，以便我们可以对其进行迭代
对于（int k=0；kmax）{
最大值