Java 无法正确断开递归代码

我写了一段代码，它将整数列表拆分为基于固定和的列表。例如，如果输入为[1,2,3,5]，固定大小为5。那么输出必须是[[1,2,2]，[1,4]，[1]]

为了实现这一点，我编写了如下代码

public class SplitListtoLists {

 public static void main(String[] args) {
    int[] intArr = {1,2,3,5};//[[1,2,2],[1,4],[1]]
    List<Integer> aList = new ArrayList<Integer>();
    aList.add(1);
    aList.add(2);
    aList.add(3);
    aList.add(5);

    System.out.println(aList);

    List<List<Integer>> aListOfList = splitList(aList,0,new ArrayList<>());
    System.out.println(aListOfList);
}

public static List<List<Integer>> splitList(List<Integer> aList, int accCount, List<List<Integer>> listOfList) {
    List<Integer> targetList = new ArrayList<>();
    for (int i = 0; i <aList.size() ; i++) {
        int number = aList.get(i);
        System.out.format("\t i=%d aList=%s targetList=%s number=%d accCount=%d \n",i,aList,targetList,number,accCount);
        System.out.format("\t list of list %s\n",listOfList);
        accCount = accCount + number;
        int batchSize = 5;
        if(accCount < batchSize) {
            targetList.add(number);
        } else if(accCount > batchSize){
            int limitedCount = accCount - batchSize;
            int currentArrNumber = number - limitedCount;
            targetList.add(currentArrNumber);
            listOfList.add(targetList);
            List<Integer> subList = new ArrayList<>();
            subList.add(limitedCount);
            subList.addAll(aList.subList(i+1,aList.size()));
            splitList(subList, 0, listOfList);
            System.out.println("\t\tAfter recursion "+listOfList);
            System.out.println("\t\ti "+i);
            aList = new ArrayList<>();
        } else {
            targetList.add(number);
            listOfList.add(targetList);
            targetList = new ArrayList<>();
            accCount = 0;
        }
    }
    listOfList.add(targetList);

    return listOfList;
}


}

[1]之后如何正确停止

提前感谢

疯狂代码；）我希望现在它是正确的

要添加列表，是不是有问题，你需要一份副本

public static List<List<Integer>> splitList(List<Integer> aList, int accCount, List<List<Integer>> listOfList){
    List<Integer> targetList = new ArrayList<>();
    for(int i = 0; i < aList.size(); i++){
        int number = aList.get(i);
        System.out.format("\t i=%d aList=%s targetList=%s number=%d accCount=%d \n", i, aList, targetList, number, accCount);
        System.out.format("\t list of list %s\n", listOfList);
        accCount = accCount + number;
        int batchSize = 5;
        if(accCount < batchSize){
            targetList.add(number);
        }else if(accCount > batchSize){
            int limitedCount = accCount - batchSize;
            int currentArrNumber = number - limitedCount;
            targetList.add(currentArrNumber);
            listOfList.add(List.copyOf(targetList));
            List<Integer> subList = new ArrayList<>();
            subList.add(limitedCount);
            subList.addAll(aList.subList(i + 1, aList.size()));
            splitList(subList, 0, listOfList);
            System.out.println("\t\tAfter recursion " + listOfList);
            System.out.println("\t\ti " + i);
            aList = new ArrayList<>();
            targetList.clear();
        }else{
            targetList.add(number);
            listOfList.add(targetList);
            targetList = new ArrayList<>();
            accCount = 0;
        }
    }
    if(!targetList.isEmpty())listOfList.add(targetList);
    
    return listOfList;
}

公共静态列表拆分列表（列表列表、int account、列表列表列表）{
List targetList=new ArrayList（）；
对于（int i=0；ibatchSize）{
int limitedCount=accCount-batchSize；
int CURRENTARRNAME=编号-限制计数；
targetList.add（当前arrNumber）；
添加（List.copyOf（targetList））；
列表子列表=新的ArrayList（）；
子列表。添加（限制计数）；
subList.addAll（aList.subList（i+1，aList.size（））；
拆分列表（子列表，0，listOfList）；
System.out.println（“\t\t在递归之后”+listOfList）；
System.out.println（“\t\ti”+i）；
aList=新的ArrayList（）；
targetList.clear（）；
}否则{
targetList.add（编号）；
添加（targetList）；
targetList=newarraylist（）；
accCount=0；
}
}
如果（！targetList.isEmpty（））listOfList.add（targetList）；
返回列表；
}

---

编辑：更好的是List.copyOf（targetList）（我也更改了代码）

非常感谢。这个有用！！

public static List<List<Integer>> splitList(List<Integer> aList, int accCount, List<List<Integer>> listOfList){
    List<Integer> targetList = new ArrayList<>();
    for(int i = 0; i < aList.size(); i++){
        int number = aList.get(i);
        System.out.format("\t i=%d aList=%s targetList=%s number=%d accCount=%d \n", i, aList, targetList, number, accCount);
        System.out.format("\t list of list %s\n", listOfList);
        accCount = accCount + number;
        int batchSize = 5;
        if(accCount < batchSize){
            targetList.add(number);
        }else if(accCount > batchSize){
            int limitedCount = accCount - batchSize;
            int currentArrNumber = number - limitedCount;
            targetList.add(currentArrNumber);
            listOfList.add(List.copyOf(targetList));
            List<Integer> subList = new ArrayList<>();
            subList.add(limitedCount);
            subList.addAll(aList.subList(i + 1, aList.size()));
            splitList(subList, 0, listOfList);
            System.out.println("\t\tAfter recursion " + listOfList);
            System.out.println("\t\ti " + i);
            aList = new ArrayList<>();
            targetList.clear();
        }else{
            targetList.add(number);
            listOfList.add(targetList);
            targetList = new ArrayList<>();
            accCount = 0;
        }
    }
    if(!targetList.isEmpty())listOfList.add(targetList);
    
    return listOfList;
}