Is there any decent way to convert multidimensional array to List>?

Question

when we have to convert single-dimensional array List type, we can simply use Arrays.asList(). But in the context of multidimensional arrays, I did not find anything similar to this. I have to manually create a List<List<T>> and fill values as per original multidimensional array. Is there any decent way to convert between these types? Java 8 way?

Answer 1

You can use Arrays.stream and map inner arrays:

<T> List<List<T>> toNestedList(T[][] array) {
    return Arrays.stream(array)
        .map(Arrays::asList)
        .collect(Collectors.toList());
}

This will create a stream of inner arrays, map them to list and collect all inner lists to an outer one.

Answer 2

The currently proposed solution creates a new list. This means that the array has to be traversed and memory has to be allocated.

Analogously to Arrays#asList, it could be desirable to not create a new list, but only a view on the given array instead. This way, even if the array contains 1000000 elements, the memory- and performance overhead of creating this list-view is practically zero.

An example of how this could be implemented:

import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.RandomAccess;

public class NestedAsList
{
    public static void main(String[] args)
    {
        String array[][] =
        {
            { "This", "is", "an" },
            { "example", "of", }, null,
            { "a", "jagged", "array" } 
        };

        List<List<String>> lists = asLists(array);
        lists.forEach(System.out::println);
    }

    /**
     * Returns a <i>view</i> on the given array, as a list where each element is
     * a <i>view</i> on the respective array element. When the array contains
     * <code>null</code> elements, then the list will contain an empty list at
     * this index.
     * 
     * @param array The array
     * @return The list view
     */
    private static <T> List<List<T>> asLists(T array[][])
    {
        Objects.requireNonNull(array);
        class ResultList extends AbstractList<List<T>> implements RandomAccess
        {
            @Override
            public List<T> get(int index)
            {
                T[] a = array[index];
                if (a == null)
                {
                    // Could return null or the empty list here...
                    return Collections.emptyList();
                }
                return Arrays.asList(a);
            }

            @Override
            public int size()
            {
                return array.length;
            }

        }
        return new ResultList();
    }
}

(By the way: I wonder where you get a multidimensional generic array from. These should be rare nowadays...)

---

Note: The answer has been updated, based on a comment by Holger: It can be beneficial to let the returned list also implement the java.util.RandomAccess interface, to indicate that it has constant-time indexed access. Many of the static utility methods in the Collections class check whether a given list is RandomAccess, and are able to perform their task more efficiently in this case.

Unfortunately, one has to create a new, local class in order to implement the additional interface, but depending on how the resulting class is supposed to be used, this can be worthwhile.

The original implementation of the asLists method was this one, which simply returned a new AbstractList, not implementing the RandomAccess interface:

private static <T> List<List<T>> asLists(T array[][])
{
    Objects.requireNonNull(array);
    return new AbstractList<List<T>>()
    {

        @Override
        public List<T> get(int index)
        {
            T[] a = array[index];
            if (a == null)
            {
                // Could return null or the empty list here...
                return Collections.emptyList();
            }
            return Arrays.asList(a);
        }

        @Override
        public int size()
        {
            return array.length;
        }
    };
}

Answer 3

Above solution is correct but does not handle null rows in the 2D array so I have below solution using stream APIs from Java 8 and it will work for null rows and generic arrays as well.

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class TwoDArrayToListOfList {
    public static void main(String[] args) {
        String [][] stringArray = new String[][]{{"John", "Alley", "Neon"}, {null}, {"Huston", "Gary"}, {"Ellen", "James", "Chris", "Jacob"}};
        List<List<String>> stringList = getListFrom2DArray(stringArray);
        stringList.forEach(list -> list.forEach(System.out::println));

        Integer [][] intArray = new Integer[][]{{1,3, 6}, {2, 4}, {null}, {6, 4, 3, 5}, {null}};
        List<List<Integer>> intList = getListFrom2DArray(intArray);
        intList.forEach(list -> list.forEach(System.out::println));

        Double [][] doubleArray = new Double[][]{{1.0,3.9, 6.7}, {2.4, 4.4}, {6.5, 4.1, 3.3, 5.2}, {null}};
        List<List<Double>> doubleList = getListFrom2DArray(doubleArray);
        doubleList.forEach(list -> list.forEach(System.out::println));
    }

    private static <T> List<List<T>> getListFrom2DArray(T[][] array) {
        return Arrays.stream(Objects.requireNonNull(array)).map(row -> Arrays.asList((row != null) ? row : (T[]) new Object[0])).collect(Collectors.toList());
    }
}