Java如何实现类似JavaScript的无限动态嵌套混合类型数组

Java是静态类型语言，原生不支持动态混合类型的集合，你可以通过两种常见方案实现无限嵌套的动态数组结构：

方案1：使用List<Object>直接实现 #

这是最简单的方式，Object是所有引用类型的父类，可同时存储Integer和List类型元素：

import java.util.ArrayList;
import java.util.List;

public class DynamicNestedArray {
    public static void main(String[] args) {
        // 构建 [1, [2, 3, [4, 5, [6, 7]]]] 结构
        List<Object> level3 = new ArrayList<>();
        level3.add(6);
        level3.add(7);

        List<Object> level2 = new ArrayList<>();
        level2.add(4);
        level2.add(5);
        level2.add(level3);

        List<Object> level1 = new ArrayList<>();
        level1.add(2);
        level1.add(3);
        level1.add(level2);

        List<Object> root = new ArrayList<>();
        root.add(1);
        root.add(level1);

        // 遍历示例
        traverseNestedArray(root);
    }

    private static void traverseNestedArray(List<Object> array) {
        for (Object element : array) {
            if (element instanceof Integer) {
                System.out.println(element);
            } else if (element instanceof List) {
                // 强转后递归遍历
                traverseNestedArray((List<Object>) element);
            }
        }
    }
}

注：该方案需要在读取元素时做类型判断和强转，适合简单场景使用。

方案2：自定义嵌套元素类（类型安全实现） #

如果你需要更规范的类型安全实现，可以自定义封装嵌套结构的类，避免unchecked类型转换：

import java.util.List;

sealed interface NestedElement permits IntElement, ListElement {
    // 统一遍历方法
    void print();
}

// 存储整数的节点
record IntElement(int value) implements NestedElement {
    @Override
    public void print() {
        System.out.println(value);
    }
}

// 存储嵌套列表的节点
record ListElement(List<NestedElement> children) implements NestedElement {
    @Override
    public void print() {
        children.forEach(NestedElement::print);
    }
}

public class TypeSafeNestedArray {
    public static void main(String[] args) {
        // 构建和JS结构一致的嵌套数组
        NestedElement level3 = new ListElement(List.of(new IntElement(6), new IntElement(7)));
        NestedElement level2 = new ListElement(List.of(new IntElement(4), new IntElement(5), level3));
        NestedElement level1 = new ListElement(List.of(new IntElement(2), new IntElement(3), level2));
        NestedElement root = new ListElement(List.of(new IntElement(1), level1));

        // 遍历
        root.print();
    }
}

注：该方案是类型安全的，编译器会帮你检查类型错误，适合复杂业务场景使用。

内容的提问来源于stack exchange，提问作者Ramana Reddy