Question

我需要一些代码示例或算法来调整应该以下一种方式工作的List<List<Integer>>：

让我们想象我们有下一个newSize和incomingList（伪代码）：

    int newSize = 4;
    List<List<Integer>> incomingList = List(List(1,2,3),List(4,5,6),List(7,8,9);

    List<List<Integer>> result = resizeListOfNestedList(newSize, incomingList)

newSize整数设置incomingList的新大小，resizeListOfNestedList应返回非奇数的下一个结果（例如4）：

    List(List(1,2),List(3,4),List(5,6),List(7,8)

，如果newSize是奇数（例如3），则接下来：

    List(List(1,2),List(3,4,5),List(6,7,8)

newSize始终大于incomingList.size()

我很感激任何建议。

更新

在google.common.Lists的帮助下，我已经完成了草稿代码（是的，它闻起来有点气味），我希望它会对某人有所帮助。

在我的情况下，方法会收到不同的incomingList.size()和newSize参数，很明显incomingList.size()/newSize将返回双值（例如，传入的list.size（）= 1000，但我们需要将其压缩到600个元素，所以我无法一直使用Lists.partition。最好在下一个代码后调用expandList：

int maxSplitValue = (int) Math.ceil((double) incomingList.size() / newSize);

List<List<Integer>> firstPortionValues = Lists.partition(
      incomingList, maxSplitValue
);//size can be less than required after double to int upper round

if (firstPortionValues.size() < maxSplitValue) {
   List<List<Integer>> expandedList = expandList(firstPortionValues, maxSplitValue)
}

结果：

Incoming list:[[0, 1], [2, 3]] 
New size value: 3
Outcoming list:[[0], [1], [2, 3]]

Incoming list:[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]
New size value: 4
Outcoming list:[[0.0], [1.0], [2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]

代码：

public List<List<Integer>> expandList(List<List<Integer>> incomingList, int newSize) {

        List<List<Integer>> resultList = new ArrayList<>();

        for (int index = 0; index < incomingList.size(); index++) {

            List<Integer> nodeList = incomingList.get(index);

            final int minPortionValue = getMinPortionValue(
                incomingList.size(), resultList.size(), nodeList.size(), index, newSize
            );

            List<List<Integer>> portionResult = splitNodeList(new ArrayList<>(nodeList), minPortionValue);

            resultList.addAll(portionResult);
        }

        return resultList;
    }

    private int getMinPortionValue(int listSize, int resultListSize, int listElementSize, int index, int newSize) {

        if (listElementSize > 1) {

            int maxPortionValue = listElementSize % 2 == 0 ? listElementSize / 2 : --listElementSize;
            boolean isOkUseMaxPortionValue = maxPortionValue + listSize - index + resultListSize <= newSize;

            if (isOkUseMaxPortionValue) {
                return maxPortionValue;
            } else {
                return getMinPortionValue(listSize, resultListSize, listElementSize - 1, index, newSize);
            }
        } else {
            return 0;
        }
    }

    private List<List<Integer>> splitNodeList(List<Integer> nodeList, int minSplitValue) {

        List<List<Integer>> result = new ArrayList<>();

        if (minSplitValue > 0) {

            result.addAll(Lists.partition(nodeList, minSplitValue));

            return result;
        } else {

            result.add(nodeList);

            return result;
        }
    }

Answer 1

为什么不使用Apache Commons和

中的ListUtils.union(list1,list2);

Java: how can I split an ArrayList in multiple small ArrayLists?

Answer 2

阅读你的问题，我可以提出做两个步骤的算法思路：

将所有子列表合并到一个列表中（使用Guava Iterables）
对步骤1的结果进行分区（使用Guava partition）

Guava有助于更多地关注我们所需要的内容而不是如何做到这一点，因此很容易翻译您的伪代码和工作代码。

所以，你可以这样：

@Test
public void test(){
    // Init lists
    List<Integer> a = Lists.newArrayList(1,2,3);
    List<Integer> b = Lists.newArrayList(4,5,6);
    List<Integer> c = Lists.newArrayList(7,8,9);

    List<List<Integer>> incomingList = Lists.newArrayList(a,b,c);
    System.out.println(incomingList);

    // Create combined list
    Iterable<Integer> tempList = Iterables.concat(incomingList);

    // Re-Partition list 
    Iterable<List<Integer>> result = Iterables.partition(tempList, 2); // New size: 2

    // Convert from Iterables to List
    List<List<Integer>> finalList = Lists.newArrayList(result);
    System.out.println(finalList);
}

输出结果为：

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]      // Incoming list
[[1, 2], [3, 4], [5, 6], [7, 8], [9]]  // Final list

上面的代码是为了轻松调试，你可以减少代码中的代码，并利用import static来使其更具可读性并具备以下功能：

import static com.google.common.collect.Iterables.*;
import static com.google.common.collect.Lists.*;

public void test(){
    List<Integer> a = newArrayList(1,2,3);
    List<Integer> b = newArrayList(4,5,6);
    List<Integer> c = newArrayList(7,8,9);

    List<List<Integer>> incomingList = newArrayList(a,b,c);
    System.out.println(incomingList);

    // Repartition
    List<List<Integer>> finalList = newArrayList(partition(concat(incomingList), 2));
    System.out.println(finalList);
}

作为结果列表的注释，partition方法创建多个N值列表，但最后一个列表的值可以更少。对于你所说的，似乎你想要一开始的较少值。我把它留给你来搜索分区方法和番石榴用法。

Answer 3

你可以编写它，纯Java7。此代码保持新的列表列表平衡，最后添加额外的元素。

public List<List<Integer>> resizeListOfNestedList(int newSize, List<List<Integer>> data) {

    ArrayList<Integer> allElements = new ArrayList<>();

    for (List<Integer> integers : data) {
        allElements.addAll(integers);
    }

    int elementsPerItem = allElements.size() / newSize;
    int extraElements  = allElements.size() % newSize;
    int indexToStartAddExtraElement = newSize - extraElements;

    ArrayList<List<Integer>> result = new ArrayList<>(newSize);
    Iterator<Integer> iterator = allElements.iterator();

    for (int i = 0; i < newSize; i++){

        int currentItemElementsCount = elementsPerItem;

        if (i >= indexToStartAddExtraElement)
            currentItemElementsCount++;

        ArrayList<Integer> current = new ArrayList<>(currentItemElementsCount);

        for (int j = 0; j < currentItemElementsCount; j++){
            current.add(iterator.next());
        }

        result.add(current);
    }

    return result;
}

Java - 调整嵌套列表的数量

3 个答案: