Java arraylist如何在子集算法中运行和重用

我不明白ArrayList在这个问题上是如何运作的

这是leetcode中一个名为“子集”的问题的算法

它基本上输出给定数组的所有子集

例如，如果[1,2,3]是给定的数组，那么输出应该是[[]、[1]、[2]、[3]、[1,2]、[1,3]、[2,3]、[1,2,3]]

这是解决这个问题的算法，但我不理解arraylist在这段代码中是如何工作的

import java.util.*;

class Subsets {

  public static List<List<Integer>> findSubsets(int[] nums) {
    List<List<Integer>> subsets = new ArrayList<>();
    // start by adding the empty subset
    subsets.add(new ArrayList<>());
    for (int currentNumber : nums) {
      // we will take all existing subsets and insert the current number in them to create new subsets
      int n = subsets.size();
      for (int i = 0; i < n; i++) {
        // create a new subset from the existing subset and insert the current element to it
        List<Integer> set = new ArrayList<>(subsets.get(i));
        set.add(currentNumber);
        subsets.add(set);
      }
    }
    return subsets;
  }

  public static void main(String[] args) {
    List<List<Integer>> result = Subsets.findSubsets(new int[] { 1, 3 });
    System.out.println("Here is the list of subsets: " + result);

    result = Subsets.findSubsets(new int[] { 1, 2, 3 });
    System.out.println("Here is the list of subsets: " + result);
  }
}

import java.util.*；
类子集{
公共静态列表查找子集（int[]nums）{
列表子集=新的ArrayList（）；
//首先添加空子集
添加（新的ArrayList（））；
对于（int currentNumber:nums）{
//我们将获取所有现有子集，并在其中插入当前编号以创建新子集
int n=子集.size（）；
对于（int i=0；i

我被卡住的代码部分

        int n = subsets.size();
            for (int i = 0; i < n; i++) {
                List<Integer> set = new ArrayList<>(subsets.get(i));
                set.add(currentNumber);
                subsets.add(set);
            }
        }

int n=子集.size（）；
对于（int i=0；i

假设n是2，currentNumber也是2。在这种情况下，我认为它只是创建了[2]，[2]，而不是[2]，[1,2]，因为每次内部循环迭代，它都会创建一个新的ArrayList，并具有与currentNumber相同的值。我不明白[1,2]是从哪里来的

---

有谁能解释一下它是如何在第二次外部读写中输出[2]，[1,2]的，或者在我不理解的地方输出的吗？

要理解

[1]

的来源，我们从第一次迭代开始：

subsets.add（newarraylist（））将空列表添加到集合中

因此，如果
currentNumber
是
1
（集合的大小也是1），它会将
1
添加到集合的空列表副本中（
get（0）
），从而产生
[1]
，然后将其添加到集合中

现在我们有了问题中的条件：集合是
[[]，[1]
，大小为2（
n=2
），下一个数字将是
2
（
currentNumber=2
）


子集
有两个元素（
n==2
）：空列表和仅包含
1
（来自上一次迭代）的列表

子集=[[]，[1]]

现在,

迭代
i=0
，将
2
添加到空列表的副本中（
get（0）
），并将结果（
[2]）
添加到
子集中

迭代
i=1
，将
2
添加到
[1]
的副本中（
get（1）
），结果
[1,2]
添加到
子集中

子集
现在是
[]、[1]、[2]、[1,2]
-下一次迭代将把
3
添加到这四个列表中每一个列表的副本中，并将生成的4个列表添加到
子集

该算法的关键是
newarraylist（subsets.get（i））
，它正在创建一个新列表，其中包含集合中已经存在的列表元素-克隆。否则，最终结果将包含重复的相同列表（具有相同的内容）。
您是否尝试使用调试器查看它的实际功能？@Happydoodle您不明白吗？您是否理解
get（0）
返回
[]
和
get（1）
返回
[1]
？您是否了解，
[]
被克隆，然后将
2
插入其中，从而产生
[2]
？而
[1]
被克隆，然后将
2
插入其中，产生
[1,2]
？您是否了解克隆被添加到
子集
，以便其大小在每次迭代中翻倍？还有什么？谢谢你的评论，但我仍然不明白当识字率I=1时，2是如何添加到[1]，结果[1,2]的。读写i=1，它仍会在该读写中生成新的arraylist，但[1]从何而来？新建arraylist（集合c）
使用原始集合中的元素创建一个新的arraylist。因此
newarraylist（subsets.get（i））
创建一个新列表，其中包含
subsets.get（i）
中所有内容的副本，即
[1]
。裁判：有道理！！新ArrayList（集合c）！我非常感激@WelBug还请考虑Scott Hunters关于调试器-它是非常有用的，不仅是寻找bug