Java Stream递归扁平化嵌套数组：异常处理与泛型类型安全实践

import java.util.Arrays;
import java.util.stream.Stream;

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) {
                    // 如果元素是数组，递归调用flatten并将其元素消费到当前流
                    for (var next : flatten(arr)) {
                        consumer.accept(next);
                    }
                } else {
                    // 否则，直接消费当前元素
                    consumer.accept(element);
                }
            })
            .toArray(); // 将流转换为Object数组
    }

    // ... main 方法或其他泛型实现
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class ArrayFlattener {

    // ... flatten(Object[] inputArray) 方法

    /**
     * 递归扁平化嵌套Object数组，返回指定泛型类型的List。
     * 适用于Java 16及以上版本。
     *
     * @param inputArray 包含嵌套数组的Object数组
     * @param tClass 目标元素的Class对象，用于类型转换
     * @param <T> 目标元素的泛型类型
     * @return 扁平化后的List<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) {
                    // 递归调用flatten并将其元素消费
                    for (var next : flatten(arr, tClass)) {
                        consumer.accept(next);
                    }
                } else {
                    // 将非数组元素强制转换为目标类型并消费
                    consumer.accept(tClass.cast(element));
                }
            })
            .toList(); // 将流转换为List<T> (Java 16+)
    }

    // ... main 方法或其他泛型实现
}

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.stream.Stream;

public class ArrayFlattener {

    // ... 其他flatten方法

    /**
     * 递归扁平化嵌套Object数组，返回指定泛型类型的数组。
     * 采用flatMap和反射机制创建泛型数组。
     *
     * @param inputArray 包含嵌套数组的Object数组
     * @param tClass 目标元素的Class对象，用于类型转换和数组创建
     * @param <T> 目标元素的泛型类型
     * @return 扁平化后的T[]数组
     */
    public static <T> T[] flatten(Object[] inputArray, Class<T> tClass) {
        // 将流转换为数组，使用反射创建正确类型的数组
        return flattenAsStream(inputArray, tClass)
            .toArray(n -> (T[]) Array.newInstance(tClass, n));
    }

    /**
     * 辅助方法：递归扁平化嵌套Object数组，返回指定泛型类型的Stream。
     *
     * @param inputArray 包含嵌套数组的Object数组
     * @param tClass 目标元素的Class对象，用于类型转换
     * @param <T> 目标元素的泛型类型
     * @return 扁平化后的Stream<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 {
                    // 否则，将非数组元素转换为目标类型并创建单元素Stream
                    return Stream.of(tClass.cast(e));
                }
            });
    }
}

import java.util.Arrays;
import java.util.List;

public class ArrayFlattenerDemo {
    public static void main(String[] args) {
        Object[] nestedIntArray = { 1, 2, new Object[]{ 3, 4, new Object[]{ 5 }, 6, 7 }, 8, 9, 10 };

        // 1. 使用返回Object[]的方法 (Java 16+)
        System.out.println("--- 返回 Object[] ---");
        Object[] flattenedObjectArray = ArrayFlattener.flatten(nestedIntArray);
        System.out.println(Arrays.toString(flattenedObjectArray)); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        // 2. 使用返回List<T>的方法 (Java 16+)
        System.out.println("\n--- 返回 List<Integer> ---");
        List<Integer> flattenedIntList = ArrayFlattener.flatten(nestedIntArray, Integer.class);
        System.out.println(flattenedIntList); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        // 演示字符串数组
        Object[] nestedStringArray = { "A", "B", new Object[]{ "C", "D", new Object[]{ "E" }, "F", "G" }, "H", "I", "J" };
        List<String> flattenedStringList = ArrayFlattener.flatten(nestedStringArray, String.class);
        System.out.println(flattenedStringList); // Output: [A, B, C, D, E, F, G, H, I, J]

        // 3. 使用返回T[]的方法 (flatMap + 反射)
        System.out.println("\n--- 返回 Integer[] (反射) ---");
        Integer[] flattenedIntArray = ArrayFlattener.flatten(nestedIntArray, Integer.class);
        System.out.println(Arrays.toString(flattenedIntArray)); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        String[] flattenedStringArray = ArrayFlattener.flatten(nestedStringArray, String.class);
        System.out.println(Arrays.toString(flattenedStringArray)); // Output: [A, B, C, D, E, F, G, H, I, J]
    }
}