Convertir un tableau de longueurs primitives en une liste de longueurs

J’ai trouvé pratique de le faire en utilisant Apache commons lang ArrayUtils ( JavaDoc , dépendance Maven )

 import org.apache.commons.lang3.ArrayUtils; ... long[] input = someAPI.getSomeLongs(); Long[] inputBoxed = ArrayUtils.toObject(input); List inputAsList = Arrays.asList(inputBoxed); 

il a aussi l’API inverse

 long[] backToPrimitive = ArrayUtils.toPrimitive(objectArray); 

EDIT: mis à jour pour fournir une conversion complète à une liste, comme suggéré par les commentaires et autres correctifs.

Depuis Java 8, vous pouvez maintenant utiliser des stream pour cela:

 long[] arr = {1,2,3,4}; List list = Arrays.stream(arr).boxed().collect(Collectors.toList()); 

 import java.util.Arrays; import org.apache.commons.lang.ArrayUtils; List longs = Arrays.asList(ArrayUtils.toObject(new long[] {1,2,3,4})); 

hallidave et jpalecek ont la bonne idée – itération sur un tableau – mais ils ne tirent pas parti d’une fonctionnalité fournie par ArrayList : puisque la taille de la liste est connue dans ce cas, vous devez le spécifier lorsque vous créez la ArrayList .

 List list = new ArrayList(input.length); for (long n : input) list.add(n); 

De cette façon, aucun tableau inutile n’est créé pour être ignoré par ArrayList car ils s’avèrent trop courts et aucun “emplacement” vide n’est gaspillé, car ArrayList surestimé ses besoins en espace. Bien sûr, si vous continuez à append des éléments à la liste, un nouveau tableau de sauvegarde sera nécessaire.

Un peu plus verbeux, mais cela fonctionne:

  List list = new ArrayList(); for (long value : input) { list.add(value); } 

Dans votre exemple, il apparaît qu’Arrays.asList () interprète l’entrée comme une liste de tableaux longs [] au lieu d’une liste de Longs. Un peu surprenant, à coup sûr. L’autoboxing ne fonctionne tout simplement pas comme vous le souhaitez.

Comme autre possibilité, la bibliothèque Guava fournit ceci comme Longs.asList() , avec des classes utilitaires similaires pour les autres types primitifs.

 import com.google.common.primitives.Longs; long[] input = someAPI.getSomeLongs(); List output = Longs.asList(input); 

Non, il n’y a pas de conversion automatique du tableau de type primitif en tableau de leurs types de référence encadrés. Vous ne pouvez que faire

 long[] input = someAPI.getSomeLongs(); List lst = new ArrayList(); for(long l : input) lst.add(l); 

J’écris une petite bibliothèque pour ces problèmes:

 long[] input = someAPI.getSomeLongs(); List = $(input).toList(); 

Dans le cas où vous le souhaitez, vérifiez-le ici .

Une autre façon avec Java 8.

 long[] input = someAPI.getSomeLongs(); LongStream.of(input).boxed().collect(Collectors.toList())); 

En combinant les réponses de Pavel et Tom, nous obtenons ceci

  @SuppressWarnings("unchecked") public static  List asList(final Object array) { if (!array.getClass().isArray()) throw new IllegalArgumentException("Not an array"); return new AbstractList() { @Override public T get(int index) { return (T) Array.get(array, index); } @Override public int size() { return Array.getLength(array); } }; } 

Une autre façon avec Java 8.

 final long[] a = new long[]{1L, 2L}; final List l = Arrays.stream(a).boxed().collect(Collectors.toList()); 

Si vous voulez une sémantique similaire à Arrays.asList vous devrez alors écrire (ou utiliser quelqu’un d’autre) l’implémentation client de List (probablement via AbstractList . Il devrait avoir la même implémentation que Arrays.asList , uniquement les valeurs box et unbox.

Vous pouvez utiliser transmorph :

 Transmorph transmorph = new Transmorph(new DefaultConverters()); List = transmorph.convert(new long[] {1,2,3,4}, new TypeReference>() {}); 

Cela fonctionne aussi si source est un tableau d’ints par exemple.

Je sais que cette question est assez ancienne, mais … vous pouvez également écrire votre propre méthode de conversion:

 @SuppressWarnings("unchecked") public static  List toList(Object... items) { List list = new ArrayList(); if (items.length == 1 && items[0].getClass().isArray()) { int length = Array.getLength(items[0]); for (int i = 0; i < length; i++) { Object element = Array.get(items[0], i); T item = (T)element; list.add(item); } } else { for (Object i : items) { T item = (T)i; list.add(item); } } return list; } 

Une fois que vous l'avez inclus en utilisant l'importation statique, les utilisations possibles peuvent être:

  long[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; List list = toList(array); 

ou

  List list = toList(1l, 2l, 3l, 4l, 5l, 6l, 7l, 8l, 9l);