Java Stream递归扁平化多维对象数组：异常与泛型处理指南

public static Integer[] flatten(Object[] inputArray) throws Exception {
    // ...
    stream.flatMap(o -> o instanceof Object[] ? flatten((Object[])o) : Stream.of(o));
    // ...
}

import java.util.Arrays;
import java.util.List;
import java.lang.reflect.Array;

public class ArrayFlattener {

    /**
     * 递归扁平化多维Object数组，返回Object数组。
     * 适用于Java 16及以上版本。
     *
     * @param inputArray 待扁平化的多维Object数组。
     * @return 扁平化后的Object数组。
     */
    public static Object[] flatten(Object[] inputArray) {
        return Arrays.stream(inputArray)
                .mapMulti((element, consumer) -> {
                    if (element instanceof Object[] arr) {
                        // 如果元素是数组，递归扁平化并将其所有元素传递给consumer
                        for (var next : flatten(arr)) {
                            consumer.accept(next);
                        }
                    } else {
                        // 如果元素不是数组，直接传递给consumer
                        consumer.accept(element);
                    }
                })
                .toArray(); // 将流收集为Object数组
    }

    // ... main 方法在后面统一展示
}

// ... (接上面的ArrayFlattener类)

    /**
     * 递归扁平化多维Object数组，返回指定泛型类型的List。
     * 适用于Java 16及以上版本。
     *
     * @param <T> 列表中元素的期望类型。
     * @param inputArray 待扁平化的多维Object数组。
     * @param tClass 列表中元素的Class对象，用于类型转换。
     * @return 扁平化后的List<T>。
     * @throws ClassCastException 如果数组中存在无法转换为T类型的元素。
     */
    public static <T> List<T> flatten(Object[] inputArray, Class<T> tClass) {
        return Arrays.stream(inputArray)
                .<T>mapMulti((element, consumer) -> { // <T> 明确mapMulti的泛型类型
                    if (element instanceof Object[] arr) {
                        for (var next : flatten(arr, tClass)) {
                            consumer.accept(next);
                        }
                    } else {
                        // 将元素强制转换为T类型并传递
                        consumer.accept(tClass.cast(element));
                    }
                })
                .toList(); // 将流收集为List<T> (Java 16+)
    }

    // ... main 方法在后面统一展示
}

// ... (接上面的ArrayFlattener类)

    /**
     * 递归扁平化多维Object数组，返回指定泛型类型的数组。
     * 适用于Java 8及以上版本。
     *
     * @param <T> 数组元素的期望类型。
     * @param inputArray 待扁平化的多维Object数组。
     * @param tClass 数组元素的Class对象，用于类型转换和数组创建。
     * @return 扁平化后的T[]数组。
     * @throws ClassCastException 如果数组中存在无法转换为T类型的元素。
     */
    public static <T> T[] flatten(Object[] inputArray, Class<T> tClass) {
        // 先将数组扁平化为一个Stream<T>
        Stream<T> flattenedStream = flattenAsStream(inputArray, tClass);
        // 使用反射创建指定类型的数组
        return flattenedStream.toArray(n -> (T[]) Array.newInstance(tClass, n));
    }

    /**
     * 辅助方法：递归扁平化多维Object数组，返回指定泛型类型的Stream。
     *
     * @param <T> Stream中元素的期望类型。
     * @param inputArray 待扁平化的多维Object数组。
     * @param tClass Stream中元素的Class对象，用于类型转换。
     * @return 扁平化后的Stream<T>。
     * @throws ClassCastException 如果数组中存在无法转换为T类型的元素。
     */
    public static <T> Stream<T> flattenAsStream(Object[] inputArray, Class<T> tClass) {
        return Arrays.stream(inputArray)
                .flatMap(e -> {
                    if (e instanceof Object[] arr) {
                        // 如果元素是数组，递归调用flattenAsStream并扁平化
                        return flattenAsStream(arr, tClass);
                    } else {
                        // 如果元素不是数组，将其转换为T类型并包装成一个单元素Stream
                        return Stream.of(tClass.cast(e));
                    }
                });
    }

    // ... main 方法在后面统一展示
}

// ... (接上面的ArrayFlattener类)

    public static void main(String[] args) {
        Object[] array = { 1, 2, new Object[]{ 3, 4, new Object[]{ 5 }, 6, 7 }, 8, 9, 10 };
        Object[] stringArray = { "A", "B", new Object[]{ "C", "D", new Object[]{ "E" }, "F", "G" }, "H", "I", "J" };

        System.out.println("--- 使用 mapMulti() 返回 Object[] (Java 16+) ---");
        Object[] flattenedObjectArray = flatten(array);
        System.out.println("Input: " + Arrays.deepToString(array));
        System.out.println("Output: " + Arrays.toString(flattenedObjectArray));
        // 预期输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        System.out.println("\n--- 使用 mapMulti() 返回 List<T> (Java 16+) ---");
        List<Integer> flattenedIntegerList = flatten(array, Integer.class);
        System.out.println("Input: " + Arrays.deepToString(array));
        System.out.println("Output (Integer List): " + flattenedIntegerList);
        // 预期输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        List<String> flattenedStringList = flatten(stringArray, String.class);
        System.out.println("Input: " + Arrays.deepToString(stringArray));
        System.out.println("Output (String List): " + flattenedStringList);
        // 预期输出: [A, B, C, D, E, F, G, H, I, J]

        System.out.println("\n--- 使用 flatMap() 返回 T[] (Java 8+) ---");
        Integer[] flattenedIntegerArray = flatten(array, Integer.class);
        System.out.println("Input: " + Arrays.deepToString(array));
        System.out.println("Output (Integer Array): " + Arrays.toString(flattenedIntegerArray));
        // 预期输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        String[] flattenedStringArray = flatten(stringArray, String.class);
        System.out.println("Input: " + Arrays.deepToString(stringArray));
        System.out.println("Output (String Array): " + Arrays.toString(flattenedStringArray));
        // 预期输出: [A, B, C, D, E, F, G, H, I, J]
    }
}