Java 将一系列列表转换为子列表，并将其存储在linkedlist类型的列表中

我已经有了一个包含值的列表类型整数，我想从索引0开始依次测试，如果一个元素范围的总和满足某个特定值，那么将该范围复制到列表中，并将其存储在linkedlist的列表中。然后再次按顺序测试，但现在从上一个范围的以下索引开始，因此如果上一个范围是索引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();
        }
    }
}

List arrayB=newlinkedlist（）//这是包含值的数组
列表p=新的LinkedList（）；//这是数组的数组
List arrayA=new LinkedList（）；//这是arrayB的范围或子列表
公共空函数（int n）//假设n=6且arrayB具有以下值{1,2,3,1,1,1,1,2}
{
整数计数=0；
用于（int w:arrayB）
{
计数=w+计数；
加上（w）；
如果（计数=n）
{
计数=0；
p、 添加（（LinkedList）arrayA）；
arrayA.clear（）；
}
}
}

---

但是，当我在arrayA中调用方法clear时，此代码失败。因此，无论使用的数据结构如何，是否有使用此逻辑的代码的替代方案？

您使用的是相同的列表引用arrayA每次将子列表添加到p中时，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
        }
    }
}

publicstaticvoidfunction（intn）//假设n=6和arrayB的值为{1,2,3,1,1,1,1,2}
{
整数计数=0；
LinkedList子列表=新建LinkedList（）；
用于（int w:arrayB）{
计数=w+计数；
子列表。添加（w）；
如果（计数=n）{
计数=0；
p、 add（（LinkedList）subList）；//p每次都添加一个新的列表引用
subList=new LinkedList（）；//创建一个新的列表对象，subList指向一个新的列表对象
}
}
}

我对这个问题的理解如下： 存在一个数组，如果它们满足某些条件，您希望从中提取特定范围的值。在这种情况下，标准是范围计算为某个总和。完成此操作后，您希望重复此过程，直到原始数据结构中的所有值都用完为止。 我将假设您的原始数据结构是一个整数数组，而生成的数据结构是一个整数数组的linkedlist

一种方法是使用全局计数器跟踪原始数组的当前索引，如下所示：

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);
    }
}

int[]originalArray={//用逗号分隔的数字列表}；
LinkedList resultingList=新建LinkedList（）；
int currentIndex=0；
公共静态无效函数（整数总和）{
int currentSum=0；
int initialIndex=currentIndex；
而（（currentSum！=totalSum）&（currentIndex<（originalArray.length-1）））{
如果（currentSum+initialArray[currentIndex]问题是，当您将链表添加到最终存储器p中时，您假设链表的元素放在其中。只引用一个指针，因此当您在下一行清除它时，所有元素都消失了

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

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

arrayA = new LinkedList<Integer>();

arrayA=newlinkedlist（）；

这样做时，您并没有丢失旧列表，因为p保留了对它的引用

另一个技巧是用有意义的名字命名列表

originalIntList、groupedIntList、singleGroupIntList可以帮助读者了解除了说明Java对象明显方面的注释之外，他们还可以做些什么。
这是一个非常长的第一句话。你在“如果一个范围的总和…”中输了我们。您甚至更早就失去了我。关于何时开始调用
LinkedList
和数组数组数组。在Java中，数组的类型与列表不同。如果您将“列表”称为“数组”，或者反之亦然，那么结果将是我们计算出“数组”的时间意思是Java数组或Java
List
@ergonaut我编辑了这篇文章，如果你看到代码，它是一系列元素的总和，例如arrayB中的元素有元素{1,2,3,1,1,1,1,2}，那么满足条件的前3个元素的总和是6（count==n）所以范围是索引0到索引2。@StephenC我用泛型集合而不是数组来编辑这个问题，但是这个问题并不限制在回答的任何替代代码中使用数组。“元素范围”是什么意思在数学意义上的范围？子列表？其他什么？我希望它的答案是完美地工作。我必须改变一行代码谢谢。是的，这是代码的问题，而且修复非常简单。下次我会考虑为代码编写有意义的名称，实际上是前一个代码的问题。我删除了arrayA对象的引用，它是由数组p的元素指向的，所以解决方案只是再次初始化数组，而不是调用方法ClearOk，很好，你得到了它！