将一系列列表转换为子列表，并将它们存储在一个链表类型列表中

Question

我已经有一个列表类型整数值，并且我想从索引零开始顺序测试，如果一个元素范围的总和满足特定值，然后将该范围复制到列表中并将其存储在链表列表中。然后再次依次测试，但是现在从前一个范围的下一个索引开始测试，所以如果前一个范围是索引0到索引9，则从索引10开始，然后重复该过程直到最后一个索引。

List<Integer> arrayB = new LinkedList<Integer>(); //this is the array with values in it 

List<LinkedList> p = new LinkedList<LinkedList>();// this is the array of arrays 

List<Integer> arrayA = new LinkedList<Integer>();// this is the range or the sub list of arrayB 

public void function(int n)// suppose that n = 6 and arrayB have these value {1,2,3,1,1,1,1,2} 
{ 
    int count = 0; 

    for (int w : arrayB) 
    { 
     count = w + count; 
     arrayA.add(w); 
     if(count == n) 
     { 
      count = 0; 
      p.add((LinkedList) arrayA); 
      arrayA.clear(); 
     } 
    } 
} 

然而，当我调用方法中arrayA清除此代码失败，因此没有任何替代使用具有这种逻辑而不管该数据结构的代码？

Answer 1

您每次向p添加子列表时都使用相同的列表引用arrayA，p中的每个列表元素都指向相同的arrayA。所以当你调用arrayA.clear（）;您清除p中的所有列表元素。

要纠正这一点，你需要创建一个新的列表对象当您添加一个子表到arrayA：

public static void function(int n)// suppose that n = 6 and arrayB have these value {1,2,3,1,1,1,1,2} 
{ 
    int count = 0; 

    LinkedList<Integer> subList = new LinkedList<>(); 
    for (int w : arrayB) { 
     count = w + count; 
     subList.add(w); 
     if (count == n) { 
      count = 0; 
      p.add((LinkedList) subList); // p is adding a new list reference every time 
      subList = new LinkedList<>(); // create a new list object, subList points to a new list object 
     } 
    } 
} 

Answer 2

我对这个问题的理解是这样的： 存在从您想一个数组在满足某些标准的情况下提取一定范围的值。在这种情况下，标准是范围评估为某个总和。完成此操作后，您希望重复该过程，直到原始数据结构中的所有值都已用尽。 我会假设你的原始数据结构是一个整数数组，并且你的结果数据结构是整数数组的链表。

一种方式做到这一点可能是保持全局计数器，用于跟踪原始数组的当前索引，如像下面这样：

int[] originalArray = {//list of numbers separated by commas}; 
LinkedList<Integer[]> resultingList = new LinkedList<>(); 
int currentIndex = 0; 

public static void function(int totalSum) { 
    int currentSum = 0; 
    int initialIndex = currentIndex; 
    while((currentSum != totalSum) && (currentIndex < (originalArray.length - 1))) { 
     if(currentSum + initialArray[currentIndex] <= totalSum) { 
      currentSum += initialArray[currentIndex]; 
      currentIndex++; 
     } 
     else { 
      break; 
     } 
    } 
    if(currentSum = totalSum) { 
     int[] arrayToAdd = new int[currentIndex - initialIndex - 1]; 
     for(int i = 0; i < currentIndex - initialIndex; i++) { 
      arrayToAdd[i] = originalArray[initialIndex + i]; 
     } 
     resultingList.add(arrayToAdd); 
    } 
} 

Answer 3

的问题是，当您添加链表插入最终存储器p中，则假定列表中的元素放在那里。只有一个指针被引用，所以当你清除它的下一行时，所有的元素都消失了。

p.add((LinkedList) arrayA); 
arrayA.clear(); 

一个技巧是将arrayA的范围移动到函数内部。这是因为它是临时的，只有一个子列表，所以它不应该在实例级别。它可以通过做

arrayA = new LinkedList<Integer>(); 

重复使用，这样做的时候，因为p被保持对它的引用您还没有失去旧列表。

另一个技巧是使用有意义的名称命名您的列表。

originalIntList，groupedIntList，singleGroupIntList帮助读者弄清楚他们可能做的不仅仅是评论，说明Java对象的明显方面。