Java 打印数组的所有子集

我试图打印数组的所有子集。例如：

Input: nums = [1,2]
Output:
[[1], [2], [1,2], []]

我已经编写了一个递归方法，假设所有这些解决方案都是从一个条件开始的，并且程序本身调用一个子数组。但是我在forArrayListsubset得到一个ConcurrentModificationException：subsets2

如何解决问题并将其转换为有效的解决方案

---

更新：我不需要一个有效的解决方案。我需要修改我自己的代码。请使用下面我自己的代码：

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

public class TestPractice {
    public static void main(String[] args){
        int[] x = {1,2};
        System.out.println(subsets(x));
    }
    
    public static List<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> subsets = new ArrayList<ArrayList<Integer>>();
        if (nums.length ==1){
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            ArrayList<Integer> subset2 = new ArrayList<Integer>();
            subset2.add(nums[0]);
            subsets.add(subset1);
            subsets.add(subset2);
            return subsets;
        }
        int[] nums_1 = new int[nums.length-1];
        for(int i = 0; i< nums.length-1; i++) {
        nums_1[i]=nums[i];
        }
        
        List<ArrayList<Integer>> subsets2= subsets(nums_1); 
        //now add nums[n] to all subsets of nums[0:n-1]
        for(ArrayList<Integer>subset: subsets2) {
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            subset1.add(nums[nums.length-1]);
            subset1.addAll(subset);
            subsets2.add(subset1);
        }
        return subsets2;
    }
    
    
}

---

迭代列表时，不要将元素添加到列表中。通过每次只选择获取或不获取当前元素，可以大大简化代码

还可以使用位掩码

---

迭代列表时，不要将元素添加到列表中。通过每次只选择获取或不获取当前元素，可以大大简化代码

还可以使用位掩码

---

它可以用迭代法和递归法求解

对于这个问题，使用LinkedList比ArrayList更快 另外，当nums.length==1时，不需要处理这种情况 迭代法 导入java.util.LinkedList； 导入java.util.List； 公共课考试实践{ 公共静态无效字符串[]args{ int[]x={1，2}； System.out.printlnsubsetx； } 公共静态列表子项[]nums{ LinkedList子集=新LinkedList； subsets.addnew LinkedList； 福林i=0；i它可以用迭代法和递归法求解

对于这个问题，使用LinkedList比ArrayList更快 另外，当nums.length==1时，不需要处理这种情况 迭代法 导入java.util.LinkedList； 导入java.util.List； 公共课考试实践{ 公共静态无效字符串[]args{ int[]x={1，2}； System.out.printlnsubsetx； } 公共静态列表子项[]nums{ LinkedList子集=新LinkedList； subsets.addnew LinkedList； 福林i=0；i 下面我创建了一个新的列表结果，并在循环内部更新结果列表，而不是子循环2

concurrentmodificationexception在循环和更新同一列表时发生，因此在循环中创建一个新列表并更新该列表，而不是subsets2.addsubset1

下面我创建了一个新的列表结果，并在循环内部更新结果列表，而不是子循环2

---

这不是一个迭代的解决方案，你调用函数recursivelyTypo，我的意思是recursiveconcurrentmodificationexception发生在你循环和更新同一个列表时，所以创建一个新的列表，并在循环中更新该列表，而不是子列表2。addsubset1@Daemon嗯，你能把答案贴出来吗？我不需要有效的解决方案。我需要修改我自己的代码！信息技术

---

不是迭代的解决方案，您调用函数recursivelyTypo我的意思是recursiveconcurrentmodificationexception在循环和更新同一列表时发生，因此创建一个新列表并在循环中更新该列表，而不是在子列表2中。addsubset1@Daemon嗯，你能把答案贴出来吗？我不需要有效的解决方案。我需要修改我自己的代码！您也可以发布类似我的递归方法吗？顺便说一句，您的迭代解决方案会打印额外的子集：[[]，[1]，[1]，[1,2]]谢谢。你们也能纠正我的递归方法吗？我一直在修正它。最后，我用迭代方法修正了它！我意识到，不应该迭代集合，同时修改其元素。当我们这样做的时候，我们得到了java.util.ConcurrentModificationException。你也可以发布一个像我一样的递归方法吗？顺便说一句，你的迭代解决方案会打印额外的子集：[[]，[1]，[1]，[1,2]]谢谢。你们也能纠正我的递归方法吗？我一直在修正它。最后，我用迭代方法修正了它！我意识到，不应该迭代集合，同时修改其元素。当我们这样做时，我们得到java.util.ConcurrentModificationException

public static Set<List<Integer>> subsets(Set<List<Integer>> result, ArrayList<Integer> curr, int[] nums, int idx) {
    result.add((List<Integer>)curr.clone());
    if(idx < nums.length){
         subsets(result, curr, nums, idx + 1);
         final ArrayList<Integer> next = (ArrayList<Integer>) curr.clone();
         next.add(nums[idx]);
         subsets(result, next, nums, idx + 1);
    }
    return result;
}
public static void main(String[] args){
    int[] x = {1,2};
    System.out.println(subsets(new HashSet<>(), new ArrayList<>(), x, 0));
}

public static Set<List<Integer>> subsets(int[] nums) {
      final Set<List<Integer>> result = new HashSet<>();
      for(int i = 0; i < 1 << nums.length; i++){
         final List<Integer> curr = new ArrayList<>();
         for(int j = 0; j < nums.length; j++){
            if(((i>>j)&1)==1) curr.add(nums[j]);
         }
         result.add(curr);
      }
      return result;
}
public static void main(String[] args){
    int[] x = {1,2,};
    System.out.println(subsets(x));
}

import java.util.ArrayList;
import java.util.List;
public class TestPractice {
    public static void main(String[] args){
        int[] x = {1,2};
        System.out.println(subsets(x));
    }
    
    public static List<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> subsets = new ArrayList<ArrayList<Integer>>();
        if (nums.length ==1){
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            ArrayList<Integer> subset2 = new ArrayList<Integer>();
            subset2.add(nums[0]);
            subsets.add(subset1);
            subsets.add(subset2);
            return subsets;
        }
        int[] nums_1 = new int[nums.length-1];
        for(int i = 0; i< nums.length-1; i++) {
        nums_1[i]=nums[i];
        }
        
        List<ArrayList<Integer>> subsets2= subsets(nums_1); 
        List<ArrayList<Integer>> result= subsets(nums_1); 
        //now add nums[n] to all subsets of nums[0:n-1]
        for(ArrayList<Integer>subset: subsets2) {
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            subset1.add(nums[nums.length-1]);
            subset1.addAll(subset);
            result.add(subset1);
        }
        return result;
    }
    
    
}