Question

我有一个值列表，其中一些可以是列表/集合或单个值。用JavaScript表示法可能看起来像：

const input = [1,2,[3,4], [5,6], 7];

我想得到：

const concatenated = [1,2,3,4,5,6,7];

所以我有这个Java代码：

      ArrayList<T> concatenated = new ArrayList<>();

      for (T v : input) {
        try{
          concatenated.addAll((Collection) v);
        }
        catch (Exception e1){
          try{
            concatenated.addAll((List) v);
          }
          catch (Exception e2){
            concatenated.add(v);
          }
        }

     }

但是对于我来说，这段代码似乎很糟糕。首先，我不知道尝试转换为List或Collection是否足够-我还应该尝试转换为其他类型吗？有什么我不容忽视的错误吗？

如何正确执行此操作？

Answer 1

除非列表中有Exception个值，否则代码不需要进行null处理。只需将instanceOf的基础强制转换为：

// Edit: Since the type of the input `Collection` is not bound strictly
List<Object> flatten(Collection<?> input) {
    List<Object> concatenated = new ArrayList<>();
    for (Object v : input) {
        if (v instanceof Collection) {
            concatenated.addAll(flatten((Collection<?>) v));
        } else {
            concatenated.add(v);
        }
    }
    return concatenated;
}

在jshell上进一步使用它会得到以下输出：

jshell> List<Object> list = List.of(1,2,List.of(3,4),List.of(5,6),7) 
list ==> [1, 2, [3, 4], [5, 6], 7]

jshell> flatten(list)
$3 ==> [1, 2, 3, 4, 5, 6, 7]

：

Answer 2

正如其他人提到的那样，对控制流使用异常并不理想。您可以改为使用instanceof运算符来测试元素是否为Collection。 answer by nullpointer就是一个很好的例子。如果您想使用更通用的选项，还可以执行以下操作：

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public static <E> List<E> deepFlatten(final Iterable<?> iterable, final Class<E> type) {
    if (type.isPrimitive() || type.isArray() || Iterable.class.isAssignableFrom(type)) {
        throw new IllegalArgumentException(
                "type must not denote a primitive, array, or java.lang.Iterable type: " + type);
    }
    final List<E> result = new ArrayList<>();
    for (final Object element : iterable) {

        if (element instanceof Iterable<?>) {
            result.addAll(deepFlatten((Iterable<?>) element, type)); // recursion

        } else if (element != null && element.getClass().isArray()) {

            if (element instanceof Object[]) {
                result.addAll(deepFlatten(Arrays.asList((Object[]) element), type)); // recursion
            } else { // primitive array
                final Iterable<?> itrArray = IntStream.range(0, Array.getLength(element))
                        .mapToObj(index -> Array.get(element, index))::iterator; // method reference
                result.addAll(deepFlatten(itrArray, type)); // recursion
            }

        } else {
            /*
             * Will throw ClassCastException if any element is not an instance
             * of "type". You could also throw a NullPointerException here if
             * you don't want to allow null elements.
             */
            result.add(type.cast(element));
        }

    }
    return result;
}

这也通过递归处理“嵌入式”数组以及Iterable。请注意，由于模棱两可，它无法处理Map；我们应该展平键或值，还是同时展平？

致电上述内容

Iterable<?> iterable = List.of(
        "A", "B", "C", "D",
        List.of("E", "F", List.of("G", "H"), "I", "J"),
        "K",
        new String[]{"L", "M", "N", "O", "P"},
        new String[][]{{"Q", "R"}, {"S", "T"}, {"U"}, {"V"}},
        new Object[]{"W", "X"},
        "Y", "Z"
);
List<String> flattened = deepFlatten(iterable, String.class);
System.out.println(flattened);

给我

[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]

请注意，字母是按顺序排列的，因为List和数组具有保证的迭代顺序。如果您的Iterable包含Set，则deepFlatten的结果可能每次都不相同。

Answer 3

使用Exceptions控制应用程序流程/业务逻辑是一种反模式。您可以阅读有关here，here和here的更多信息。

关于在Collection中存储不同类型的元素可能很难调试和维护。您可以编写自己的包装器，并封装其用法。您可以参考this以获得灵感。

如何将列表串联成一个列表

3 个答案: