Comment créer ArrayList (ArrayList<Integer>) de la matrice (int[]) en Java

J'ai vu la question: Créer liste de tableaux à partir de la matrice de

Cependant, lorsque j'essaie cette solution avec le code suivant, il ne fonctionne pas dans tous les cas:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class ToArrayList {

    public static void main(String[] args) {
        //this works
        String[] elements = new String[] { "Ryan", "Julie", "Bob" };
        List<String> list = new ArrayList<String>(Arrays.asList(elements));
        System.out.println(list);

        //this works
        List<Integer> intList = null;
        intList = Arrays.asList(3, 5);
        System.out.println(intList);

        int[] intArray = new int[] { 0, 1 };
        //this doesn't work!
        intList = new ArrayList<Integer>(Arrays.asList(intArray));
        System.out.println(intList);
    }
}

Ce que je fais mal ici? Ne pas le code intList = new ArrayList<Integer>(Arrays.asList(intArray)); compiler bien?

Merci pour toutes les réponses. J'ai trouvé plusieurs raisons à cela des erreurs de compilation: 1. Java n'est pas autobox primitive tableaux. 2. Varargs sont compliqués à utiliser correctement - stackoverflow.com/questions/2925153/...
+1 c'est une bonne question. Je recommande à tous la lecture pour la lecture de toutes les réponses, elles s'ajoutent toutes les informations importantes.

InformationsquelleAutor tuxdna | 2013-07-08

28

Le problème dans
```
intList = new ArrayList<Integer>(Arrays.asList(intArray));
```
est que int[] est considérée comme un seul Object exemple depuis une primitive de tableau s'étend de Object. Cela ne peut fonctionner que si vous avez Integer[] au lieu de int[] depuis maintenant, vous êtes à l'envoi d'un tableau de Object.
```
Integer[] intArray = new Integer[] { 0, 1 };
//now you're sending a Object array
intList = new ArrayList<Integer>(Arrays.asList(intArray));
```
De votre commentaire: si vous voulez toujours utiliser un int[] (ou une autre primitive de type array) comme principales données, alors vous avez besoin pour créer un autre tableau avec la classe wrapper. Pour cet exemple:
```
int[] intArray = new int[] { 0, 1 };
Integer[] integerArray = new Integer[intArray.length];
int i = 0;
for(int intValue : intArray) {
    integerArray[i++] = intValue;
}
intList = new ArrayList<Integer>(Arrays.asList(integerArray));
```
Mais puisque vous êtes déjà à l'aide d'un for boucle, je n'aurais pas l'esprit à l'aide d'un temp classe wrapper tableau, il suffit d'ajouter vos articles directement dans la liste:
```
int[] intArray = new int[] { 0, 1 };
intList = new ArrayList<Integer>();
for(int intValue : intArray) {
    intList.add(intValue);
}
```
- Merci pour votre réponse. Comment puis-je convertir une primitive de tableau de boîte de tableau au lieu d'en créer une nouvelle ( ex. pas à l'aide d'une boucle )? Je ne suis impatient à un compact morceau de code que je peux utiliser.
InformationsquelleAutor Luiggi Mendoza

Avec Java 8, vous pouvez le faire en une seule ligne:

 
int[] intArr = { 1, 1, 2, 3, 5, 8, 11}; 
Liste<Integer> liste = Arrays.flux(intArr).en boîte().recueillir des(Collectionneurs.toList()); 
liste.forEach(Système d'.out::println);

InformationsquelleAutor max

7

La question est à propos de l'autoboxing. Java convertit automatiquement int à Integer automatiquement, mais il ne convertit pas int[] à Integer[]. D'où la raison.
```
public static <T> List<T> asList(T... a)
```
asList est défini comme ci-dessus. Il s'attend à un vararg de type T. c'est à dire qu'il peut prendre un tableau d'objets de type T. Dans votre cas, parce que Java ne peut pas convertir int[] à Integer[], d'où il prend type T comme int[] plutôt que Integer comme souhaité. Par conséquent, vous obtenez une liste de type List<int[]. Vous devrez manuellement le convertir en `Integer[] de int[]

Il y a un excellent article dans le livre Effective Java par Joshua Bloch, où il explique le puits avec de la varargs et c'est l'un d'entre eux.

InformationsquelleAutor Jatin

Il ne fonctionne pas parce que vous êtes à l'aide d'un int[] au lieu de Integer[]. Essayez ceci:

Integer[] intArray = new Integer[] { 0, 1 };
//this should work now
intList = new ArrayList<Integer>(Arrays.asList(intArray));

InformationsquelleAutor osorio

3

Collection veut des Objets et des primitives de ne pas dériver de l'Objet. donc Integer permettre, mais int n'est pas autoriser.

Donc vous devez utiliser une classe wrapper Integer au lieu de int qui est de type primitif.

Juste exemple:
```
 Integer[] intArray = new Integer[] { 0, 1 };
 intList = new ArrayList<Integer>(Arrays.asList(intArray));
```
InformationsquelleAutor bNd

Vous devez vous connecter pour publier un commentaire.