Convertir un tableau de primitif aspire dans une Liste de Longs

Depuis Java 8 vous pouvez maintenant utiliser les flux pour que:

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

hallidave et jpalecek ont la bonne idée—une itération sur un tableau—mais ils ne profitent pas d'une fonctionnalité fournie par ArrayList: depuis la taille de la liste est connu dans ce cas, vous devez le spécifier lorsque vous créez le ArrayList.

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

De cette façon, pas de superflu tableaux sont créés uniquement à être rejeté par le ArrayList parce qu'ils s'avèrent être trop court, et pas vide de "slots" sont perdues parce que les ArrayList surestimé ses exigences en matière d'espace. Bien sûr, si vous continuez à ajouter des éléments à la liste, un nouveau support de tableau sera nécessaire.

Comme autre possibilité, la Goyave bibliothèque fournit ce que Longs.asList(), avec les mêmes classes utilitaires pour les autres types de primitives.

import com.google.common.primitives.Longs;

long[] input = someAPI.getSomeLongs();
List<Long> output = Longs.asList(input);

D'une autre façon avec Java 8.

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

^{La question posée sur la façon de transformer un tableau dans une liste. La plupart des réponses jusqu'à présent ont montré comment créer un nouveau liste avec le même contenu, comme le tableau, ou en référence à des bibliothèques tierces. Cependant, il y a de simple, intégré dans les options pour ce genre de conversion. Certains d'entre eux ont déjà été esquissé dans d'autres réponses (par exemple,cette une). Mais je tiens à souligner et développer certains degrés de liberté pour la mise en œuvre ici, et de montrer le potentiel des avantages, des inconvénients et des mises en garde.}

Il y a au moins deux distinctions importantes à faire:

• Si la liste doit être un vue sur le tableau ou si elle devrait être un nouveau liste
• Si la liste doit être modifiables ou pas

Les options seront résumés ici rapidement, et un exemple complet de programme est affiché au bas de cette réponse.

---

La création d'une nouvelle liste en rapport à la création d'un vue sur le tableau

Lorsque le résultat devrait être une nouveau liste, puis l'une des approches de l'autre les réponses peuvent être utilisés:

List<Long> list = Arrays.stream(array).boxed().collect(Collectors.toList());

Mais on doit considérer les inconvénients de le faire: Un tableau avec 1000000 long valeurs occupent environ 8 méga-octets de mémoire. La nouvelle liste sera aussi occupent environ 8 mo. Et bien sûr, toute la gamme a être parcourus lors de la création de cette liste. Dans de nombreux cas, la création d'une nouvelle liste est tout simplement pas nécessaire. Au lieu de cela, il suffit de créer un vue sur le tableau:

//This occupies ca. 8 MB
long array[] = { /* 1 million elements */ }

//Properly implemented, this list will only occupy a few bytes,
//and the array does NOT have to be traversed, meaning that this
//operation has nearly ZERO memory- and processing overhead:
List<Long> list = asList(array);

^{(Voir l'exemple dans le bas pour une mise en œuvre de la toList méthode)}

L'implication d'avoir un vue sur le tableau sont que des changements dans la matrice sera visible dans la liste:

long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);

System.out.println(list.get(1)); //This will print 34

//Modify the array contents:
array[1] = 12345;

System.out.println(list.get(1)); //This will now print 12345!

Heureusement, la création d'une copie (c'est un nouveau liste qui n'est pas affectée par les modifications dans le tableau) à partir de la vue est trivial:

List<Long> copy = new ArrayList<Long>(asList(array));

Maintenant, c'est une copie conforme, soit l'équivalent de ce qui est réalisé avec la solution d'analyse de flux qui a été montré ci-dessus.

---

La création d'un modifiables vue ou un inmodifiable vue

Dans de nombreux cas, il sera suffisant lorsque la liste est en lecture seule. Le contenu de la liste résultante souvent de ne pas être modifié, mais seulement passé pour le traitement en aval qui ne lit la liste.

Permettant des modifications de la liste des questions à se poser:

long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);

list.set(2, 34567);           //Should this be possible?
System.out.println(array[2]); //Should this print 34567?
list.set(3, null);            //What should happen here?
list.add(99999);              //Should this be possible?

Il est possible de créer une vue de liste sur le tableau qui est modifiables. Cela signifie que les changements dans la liste, comme la fixation d'une nouvelle valeur à un certain indice, sera visible dans le tableau.

Mais il n'est pas possible de créer une liste structurellement modifiables. Cela signifie qu'il n'est pas possible de faire les opérations qui affectent la taille de la liste. C'est tout simplement parce que la taille du sous-jacent tableau ne peut pas être modifié.

---

Ce qui suit est une MCVE montrant les différentes options de mise en œuvre, et la manière d'utiliser les listes résultant:

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.RandomAccess;
public class PrimitiveArraysAsLists
{
public static void main(String[] args)
{
long array[] = { 12, 34, 56, 78 };
//Create VIEWS on the given array
List<Long> list = asList(array);
List<Long> unmodifiableList = asUnmodifiableList(array);
//If a NEW list is desired (and not a VIEW on the array), this
//can be created as well:
List<Long> copy = new ArrayList<Long>(asList(array));
System.out.println("array           : " + Arrays.toString(array));
System.out.println("list            : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy            : " + copy);        
//Modify a value in the array. The changes will be visible
//in the list and the unmodifiable list, but not in
//the copy.
System.out.println("Changing value at index 1 of the array...");
array[1] = 34567;
System.out.println("array           : " + Arrays.toString(array));
System.out.println("list            : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy            : " + copy);        
//Modify a value of the list. The changes will be visible
//in the array and the unmodifiable list, but not in
//the copy.
System.out.println("Changing value at index 2 of the list...");
list.set(2, 56789L);
System.out.println("array           : " + Arrays.toString(array));
System.out.println("list            : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy            : " + copy);        
//Certain operations are not supported:
try
{
//Throws an UnsupportedOperationException: This list is 
//unmodifiable, because the "set" method is not implemented
unmodifiableList.set(2, 23456L);
}
catch (UnsupportedOperationException e) 
{
System.out.println("Expected: " + e);
}
try
{
//Throws an UnsupportedOperationException: The size of the
//backing array cannot be changed
list.add(90L);
}
catch (UnsupportedOperationException e) 
{
System.out.println("Expected: " + e);
}
try
{
//Throws a NullPointerException: The value 'null' cannot be  
//converted to a primitive 'long' value for the underlying array
list.set(2, null);
}
catch (NullPointerException e)
{
System.out.println("Expected: " + e);
}
}
/**
* Returns an unmodifiable view on the given array, as a list.
* Changes in the given array will be visible in the returned
* list.
*  
* @param array The array
* @return The list view
*/
private static List<Long> asUnmodifiableList(long array[])
{
Objects.requireNonNull(array);
class ResultList extends AbstractList<Long> implements RandomAccess
{
@Override
public Long get(int index)
{
return array[index];
}
@Override
public int size()
{
return array.length;
}
};
return new ResultList();
}
/**
* Returns a view on the given array, as a list. Changes in the given 
* array will be visible in the returned list, and vice versa. The
* list does not allow for <i>structural modifications</i>, meaning
* that it is not possible to change the size of the list.
*  
* @param array The array
* @return The list view
*/
private static List<Long> asList(long array[])
{
Objects.requireNonNull(array);
class ResultList extends AbstractList<Long> implements RandomAccess
{
@Override
public Long get(int index)
{
return array[index];
}
@Override
public Long set(int index, Long element)
{
long old = array[index];
array[index] = element;
return old;
}
@Override
public int size()
{
return array.length;
}
};
return new ResultList();
}
}

La sortie de l'exemple est illustré ici:

array           : [12, 34, 56, 78]
list            : [12, 34, 56, 78]
unmodifiableList: [12, 34, 56, 78]
copy            : [12, 34, 56, 78]
Changing value at index 1 of the array...
array           : [12, 34567, 56, 78]
list            : [12, 34567, 56, 78]
unmodifiableList: [12, 34567, 56, 78]
copy            : [12, 34, 56, 78]
Changing value at index 2 of the list...
array           : [12, 34567, 56789, 78]
list            : [12, 34567, 56789, 78]
unmodifiableList: [12, 34567, 56789, 78]
copy            : [12, 34, 56, 78]
Expected: java.lang.UnsupportedOperationException
Expected: java.lang.UnsupportedOperationException
Expected: java.lang.NullPointerException

Un autre façon avec Java 8.

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

Vous pouvez utiliser transmorph :

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

Il fonctionne également si la source est un tableau d'entiers par exemple.

Alors qu'il est possible de créer une nouvelle Liste et d'y ajouter toutes les valeurs (par l'intermédiaire de la boucle ou des cours d'eau), j'ai travaillé sur de grands tableaux et d'obtenir des performances médiocres. Donc j'ai créé mon propre facile à utiliser primitive de la matrice de classe wrapper.

Exemple:

long[] arr = new long[] {1,2,3};
PrimativeList<Long> list = PrimativeList.create(arr); //detects long[] and returns PrimativeList<Long>
System.out.println(list.get(1)); //prints: 2
list.set(2, 15);
System.out.println(arr[2]);  //prints: 15

L'obtenir ici:
https://github.com/Sf298/Sauds-Toolbox/blob/master/src/main/java/PrimitiveArrayWrapper/PrimitiveList.java

REMARQUE: je n'ai pas entièrement encore testé, alors laissez-moi savoir si vous trouvez des bugs/problèmes.