Convert Collection> to 2D array T[][]

Question

Possible Duplicate:
Convert ArrayList into 2D array containing varying lengths of arrays

How can I convert a Collection<List<Foo>> into a 2D array of type Foo[][]?

I'm trying to use the toArray method, but I'm not sure about the syntax. For instance, this doesn't work:

import com.google.common.collect.Collections2;
Collection<List<Foo>> permuted = Collections2.permutations(bar);
Foo[][] permutedArray = permuted.toArray(new Foo[10][10]);//exception here

it's throwing ArrayStoreException. In this case, what should be the type for permutedArray?

yes they do, let suppose the size is `size`. But can the size be determined at runtime? — Chin, Dec 22 '12 at 16:34
It's a specific class. I changed the question to remove the ambiguity — Chin, Dec 22 '12 at 18:10

score 3 · Accepted Answer · edited Dec 23 '12 at 00:45

3

.toArray can only convert the collection into a List<Foo>[]. You need to call .toArray on each element of the array of list again to really get a Foo[][].

    @SuppressWarnings("unchecked")
    final List<Foo>[] permutedList = permuted.toArray(new List[10]);
    final Foo[][] permutedArray = new Foo[10][10];
    for (int j = 0; j < 10; ++j) {
        permutedArray[j] = permutedList[j].toArray(new Foo[10]);
    }

edited Dec 23 '12 at 00:45

Chin

19,717
37
107
164

answered Dec 22 '12 at 16:50

kennytm

510,854
105
1,084
1,005

there's an error on `new List[10]` : `Cannot create a generic array of List` – Chin Dec 22 '12 at 16:58
Have you defined Foo? `public Foo[][] deconstruct(Collection> colleciton)` should work – Daniel B. Chapman Dec 22 '12 at 17:05
yes Foo is defined, strange though... – Chin Dec 22 '12 at 18:19
@Chin: Check update. It seems the only way to work is to use unchecked conversion. – kennytm Dec 22 '12 at 18:36

score 1 · Answer 2 · answered Dec 22 '12 at 17:03

This seems like it might make more sense to do a set of nested loops:

//Untested, I might have made some silly mistake
T[][] array = new T[collection.size()[];
int collection = 0;
int list = 0;

for(List<T> list : collection)
{
  list = 0;
  array[collection] = new T[list.size()];
  for(T t : list)
    array[collection][list++] = t;

  collection++;
}

The "toArray" method is handy, but because of Generic types I usually find it frustrating to work with. Utility methods like this generally read easier and avoid the problems you're running into.

EDIT: I should note: you need to know or cast T. It will generate an unchecked types exception (which of course is unchecked!).

cambecc · Answer 3 · 2012-12-22T18:37:29.727

What if you try something like the following generic utility function:

public static <T> T[][] asMatrix(
    Collection<? extends Collection<? extends T>> source,
    T[][] target) {

    // Create a zero-sized array which we may need when converting a row.
    @SuppressWarnings("unchecked") T[] emptyRow =
        (T[])Array.newInstance(target.getClass().getComponentType().getComponentType(), 0);

    List<T[]> rows = new ArrayList<T[]>(source.size());
    int i = 0;
    for (Collection<? extends T> row : source) {
        T[] targetRow = i < target.length ? target[i] : null;
        rows.add(row.toArray(targetRow != null ? targetRow : emptyRow));
        i += 1;
    }
    return rows.toArray(target);
}

Usage:

Collection<List<Foo>> permuted = ...;
Foo[][] result = asMatrix(permuted, new Foo[][] {});

The way it works is to visit each sub collection (i.e., row), converting it into an array. We cache these arrays in a collection. We then ask that collection to convert itself into an array, which we use as the result of the function.

The benefits of this utility function are:

It uses Collection.toArray for all of the array construction and copying.
The function is generic and so can handle any kind of reference type (unfortunately native types like int, long, etc., will require more work).
You pass in the target array, which might even be preallocated to a certain size, behaving exactly the same as Collection.toArray does.
The function is tolerant of collections that change their size concurrently (as long as the collections are themselves tolerant).
The conversion is type safe and type strict.

More examples:

List<List<Integer>> list =
    Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4));

Integer[][] result;

result = asMatrix(list, new Integer[][] {});
System.out.println(Arrays.deepToString(result));

result = asMatrix(list, new Integer[][] {new Integer[] {9, 9, 9, 9}, null});
System.out.println(Arrays.deepToString(result));

Result:

[[1, 2], [3, 4]]
[[1, 2, null, 9], [3, 4]]

Convert Collection> to 2D array T[][]

3 Answers3