Convertir flux <flux <T >> à T [] [] avec Streams / Lambda de Java

JavaJd:

Je cherche à voir s'il y avait une meilleure façon de résoudre mon dilemme d'avoir à utiliser ces signatures (note: T [] [] est nécessaire en raison de tests Spock et je fournit T [] [] en tant que fournisseur de données)

Ma signature de la méthode est:

public <T> T[][] createArrays(Class<T> clazz, T...items)

J'utilise une méthode statique qui a la signature:

public static <T> Stream<Stream<T>> of(T...items)

et calcule toutes les permutations du tableau passé.

Ma solution, retapé à la main donc pardonner les fautes de frappe, est:

public static <T> T[][] createArrays(Class<T> clazz, T...items){
  Stream<Stream<T>> streams = EnumPerm.of(items);
  List<List<T>> lists = streams.map(s -> ).collect(toList()).collect(toList());
  T[][] outer = (T[][])(Array.newInstance(clazz,lists.size(),items.length);
  for(int x=0;x<lists.size();x++){
    List<T> innerList = lists.get(x);
    for(int y=0;y<items.length;y++){
      outer[x][y] = innerList.get(x);
    }      
  }

  return outer;
}

Je tentais .map (s -> s.toArray (....)) mais n'a pas pu obtenir T [] fonte au travail, le générateur de IntFunction au travail, ni utiliser les Array.newInstance au travail. Il me manque probablement quelque chose et apprécierais beaucoup des suggestions.

Faites attention et je vous remercie de votre temps à l'avance !!

Holger:

Vous pouvez utiliser Array.newInstancecomme ceci:

public static <T> T[][] createArrays(Class<T> clazz, T... items) {
    Stream<Stream<T>> streams = EnumPerm.of(items);
    return streams
        .map(s -> s.toArray(len -> (T[])Array.newInstance(clazz, len)))
        .toArray(len -> (T[][])Array.newInstance(items.getClass(), len));
}

sans intermédiaires Lists.

Il existe une variante pour créer des matrices du même type sans moulages non contrôlés, comme celui-ci

public static <T> T[][] createArrays(Class<T> clazz, T... items) {
    Stream<Stream<T>> streams = EnumPerm.of(items);
    T[] template = Arrays.copyOf(items, 0);
    return streams
        .map(s -> s.toArray(len -> Arrays.copyOf(template, len)))
        .toArray(len -> (T[][])Array.newInstance(template.getClass(), len));
}

mais comme il n'y a pas de tableau existant de type T[][], nous ne pouvons pas éviter Array.newInstancede créer le tableau extérieur. Mais attention qui est n'a pas besoin du clazzparamètre.

Si vous souhaitez appliquer l'utilisation du spécifié clazzparamètre pour tous les tableaux, vous pouvez utiliser

public static <T> T[][] createArrays(Class<T> clazz, T... items) {
    Stream<Stream<T>> streams = EnumPerm.of(items);
    return streams
        .map(s -> s.toArray(len -> (T[])Array.newInstance(clazz, len)))
        .toArray(len -> (T[][])Array.newInstance(clazz, len, 0));
}