如何遍历多层嵌套的ArrayList，支持foreach等多种循环方式

固定层数嵌套遍历 #

如果你的嵌套层数是确定的，比如你示例中的5层嵌套结构，直接使用对应层数的foreach循环即可实现遍历，示例代码如下：

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // 5层嵌套ArrayList初始化
        ArrayList<ArrayList<ArrayList<ArrayList<ArrayList<Object>>>>> fiveLayerList = new ArrayList<>();
        
        // 5层foreach遍历
        for (ArrayList<ArrayList<ArrayList<ArrayList<Object>>>> fourthLayer : fiveLayerList) {
            for (ArrayList<ArrayList<ArrayList<Object>>> thirdLayer : fourthLayer) {
                for (ArrayList<ArrayList<Object>> secondLayer : thirdLayer) {
                    for (ArrayList<Object> firstLayer : secondLayer) {
                        for (Object element : firstLayer) {
                            // 此处编写最内层元素的处理逻辑
                            System.out.println(element);
                        }
                    }
                }
            }
        }
    }
}

不固定层数（无限层）嵌套遍历 #

如果嵌套层数是动态变化的，固定层数的循环无法适配，推荐使用以下两种方案：

方案1：递归遍历 #

实现逻辑最简单，适配绝大多数普通场景，示例代码如下：

import java.util.ArrayList;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        // 任意层数的嵌套ArrayList
        ArrayList<ArrayList<ArrayList<Object>>> dynamicList = new ArrayList<>();
        // 调用遍历方法
        traverse(dynamicList);
    }

    public static void traverse(Object obj) {
        // 判断当前节点是否为集合类型，是则继续遍历子节点
        if (obj instanceof Collection<?>) {
            for (Object item : (Collection<?>) obj) {
                traverse(item);
            }
        } else {
            // 到达最内层元素，此处编写处理逻辑
            System.out.println(obj);
        }
    }
}

注意：嵌套层数过深时递归会触发栈溢出风险，极端场景下使用非递归方案更稳妥。

方案2：非递归遍历（深度优先） #

用栈数据结构模拟递归逻辑，避免栈溢出问题，示例代码如下：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Stack;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        ArrayList<ArrayList<ArrayList<Object>>> dynamicList = new ArrayList<>();
        traverseNoRecursion(dynamicList);
    }

    public static void traverseNoRecursion(Object root) {
        if (!(root instanceof Collection<?>)) {
            System.out.println(root);
            return;
        }
        Stack<Object> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Object current = stack.pop();
            if (current instanceof Collection<?>) {
                List<?> tempList = new ArrayList<>((Collection<?>) current);
                // 倒序压栈保证遍历顺序和递归遍历一致，不需要匹配顺序可删除倒序逻辑
                for (int i = tempList.size() - 1; i >= 0; i--) {
                    stack.push(tempList.get(i));
                }
            } else {
                // 处理最内层元素
                System.out.println(current);
            }
        }
    }
}

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