服务器性能瓶颈：如何高效扁平化List<Object>为List<SomeObject>？

问题背景 #

我的服务器出现性能瓶颈，原因是需要将List<ParentObject>（每个ParentObject包含List<SomeObject>类型的childList）扁平化为List<SomeObject>，导致CPU使用率异常飙升。

数据结构定义：

class ParentObject {
    private List<SomeObject> childList;

    // 省略getter方法
}

已尝试的两种实现方式：

• 流式实现：

parentList.stream().flatMap(child -> child.getChildList().stream()).collect(Collectors.toList())

• 循环添加实现：

List<SomeObject> all = new ArrayList<>();
parentList.forEach(child -> all.addAll(child.getChildList()))

两种方式计算开销相近，但底层元素复制操作导致CPU开销过高，寻求更优实现方案。

优化方案 #

1. 预分配ArrayList容量（最易实现的优化） #

默认ArrayList初始容量为10，每次扩容都会触发数组复制，这是主要的CPU开销来源之一。先计算所有子列表的总元素数，一次性初始化足够大的容量，彻底避免扩容复制：

// 计算总元素数
int totalSize = 0;
for (ParentObject p : parentList) {
    totalSize += p.getChildList().size();
}
// 初始化容量足够的ArrayList
List<SomeObject> all = new ArrayList<>(totalSize);
// 批量添加元素
parentList.forEach(p -> all.addAll(p.getChildList()));

此方法能显著减少数组拷贝次数，且代码改动极小，适合大多数场景。

2. 使用懒加载视图列表（零拷贝方案） #

如果仅需读取扁平化后的列表、无需修改元素，可以返回一个视图列表——不实际复制元素，而是在访问时动态从子列表中获取。这种方式完全避免元素复制，CPU开销极低。

自定义视图List实现

class FlattenedSomeObjectList extends AbstractList<SomeObject> {
    private final List<ParentObject> parentList;
    private int totalSize; // 缓存总长度，避免重复计算

    public FlattenedSomeObjectList(List<ParentObject> parentList) {
        this.parentList = parentList;
        this.totalSize = calculateTotalSize();
    }

    private int calculateTotalSize() {
        int size = 0;
        for (ParentObject p : parentList) {
            size += p.getChildList().size();
        }
        return size;
    }

    @Override
    public SomeObject get(int index) {
        int currentOffset = 0;
        for (ParentObject p : parentList) {
            List<SomeObject> children = p.getChildList();
            int childSize = children.size();
            if (index < currentOffset + childSize) {
                return children.get(index - currentOffset);
            }
            currentOffset += childSize;
        }
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + totalSize);
    }

    @Override
    public int size() {
        return totalSize;
    }
}

使用方式：

List<SomeObject> flattened = new FlattenedSomeObjectList(parentList);
// 直接遍历读取即可，无元素复制
for (SomeObject obj : flattened) {
    // 处理逻辑
}

注意：此方案仅适合只读场景，且随机访问元素时会遍历父列表定位，适合遍历次数少、顺序访问的场景。

3. 手动数组拷贝（极端性能优化） #

如果子列表大多是ArrayList，可以直接操作内部数组进行批量拷贝，跳过addAll的边界检查和循环开销：

// 计算总元素数
int totalSize = 0;
for (ParentObject p : parentList) {
    totalSize += p.getChildList().size();
}

// 初始化目标数组
SomeObject[] targetArray = new SomeObject[totalSize];
int currentPos = 0;

for (ParentObject p : parentList) {
    List<SomeObject> children = p.getChildList();
    if (children instanceof ArrayList) {
        // 强制转为ArrayList，直接获取内部数组拷贝
        ArrayList<SomeObject> childArrayList = (ArrayList<SomeObject>) children;
        Object[] childInternalArray = childArrayList.toArray();
        System.arraycopy(childInternalArray, 0, targetArray, currentPos, childInternalArray.length);
        currentPos += childInternalArray.length;
    } else {
        // 非ArrayList类型，逐个添加
        for (SomeObject obj : children) {
            targetArray[currentPos++] = obj;
        }
    }
}

// 转成List（如需可修改则用new ArrayList<>(Arrays.asList(targetArray))）
List<SomeObject> all = Arrays.asList(targetArray);

此方案通过System.arraycopy（native方法）实现高效批量拷贝，比普通addAll性能更高，但代码复杂度稍高，适合对性能要求极高的场景。

4. 并行流（谨慎使用） #

仅当父列表规模极大（十万级以上元素）、且子列表处理无依赖时，可尝试并行流分摊CPU负载，但需注意线程调度开销：

// 预计算总容量，避免扩容
int totalSize = parentList.parallelStream().mapToInt(p -> p.getChildList().size()).sum();
List<SomeObject> all = parentList.parallelStream()
        .flatMap(p -> p.getChildList().stream())
        .collect(Collectors.toCollection(() -> new ArrayList<>(totalSize)));

小数据量下并行流的线程开销会抵消性能收益，需实际测试验证效果。

内容的提问来源于stack exchange，提问作者Nabil Ahmed