Comment convertir int [] en List <Integer> en Java?

383

Comment convertir int[]en List<Integer>Java?

Bien sûr, je suis intéressé par une autre réponse que de le faire en boucle, article par article. Mais s'il n'y a pas d'autre réponse, je choisirai celle-ci comme la meilleure pour montrer que cette fonctionnalité ne fait pas partie de Java.

pupeno
la source
Nous pouvons utiliser IntStream.Of (array) .collect (Collectors.toList)
Saroj Kumar Sahoo

Réponses:

259

Il n'y a pas de raccourci pour convertir de int[]en List<Integer>car Arrays.asListne traite pas de la boxe et créera simplement un List<int[]>qui n'est pas ce que vous voulez. Vous devez créer une méthode utilitaire.

int[] ints = {1, 2, 3};
List<Integer> intList = new ArrayList<Integer>(ints.length);
for (int i : ints)
{
    intList.add(i);
}
willcodejavaforfood
la source
32
Il est préférable d'initialiser la liste avec la taille du tableau
David Rabinowitz
110
for (int i: ints) intList.add (i);
Stephen Denne
18
@willcodejavaforfood - David signifie que c'est mieux: new ArrayList <Integer> (ints.length);
Stephen Denne
12
@willcodejavaforfood: déclarer la taille de ArrayList lors de sa construction l'empêchera de redimensionner en interne après l'ajout d'un certain montant. Je ne sais pas si l'avantage est faible, mais il y a certainement un avantage.
Grundlefleck
10
new ArrayList<Integer>() {{ for (int i : ints) add(i); }}
saka1029
350

Ruisseaux

Dans Java 8, vous pouvez le faire

int[] ints = {1,2,3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());
mikeyreilly
la source
21
Équivalent à: Arrays.stream (ints) .boxed (). Collect (Collectors.toList ());
njfrost
4
@njfrost Vous avez raison et IntStream.of appelle simplement Arrays.stream, j'ai donc amélioré la réponse suite à votre suggestion
mikeyreilly
Pour une raison quelconque, cela ne semble pas renvoyer le type de résultat attendu sur Android Studio (fonctionne sur eclipse).
Eugenio Lopez
Il a l'air propre et concis mais quand j'ai utilisé cela contrairement à la solution de base fournie par @willcodejavaforfood sur leetcode, les performances du programme se sont dégradées en termes de mémoire et d'exécution
chitresh sirohi
@chitreshsirohi c'est parce que les fonctions lambda utilisées dans les flux entraînent Java pour créer des classes anonymes.
Ashvin Sharma
175

Aussi à partir des bibliothèques de goyaves ... com.google.common.primitives.Ints:

List<Integer> Ints.asList(int...)
louisgab
la source
11
Celui-ci devrait être la bonne réponse. Voir la deuxième phrase de la question: "Bien sûr, je suis intéressé par une autre réponse que de le faire en boucle, élément par élément."
josketres
Merci merci merci! Fonctionne également pour Longs.asList (long ...).
craastad
2
Il y a ici quelques subtilités. La liste renvoyée utilise le tableau fourni comme magasin de sauvegarde, vous ne devez donc pas muter le tableau. La liste ne garantit pas non plus l'identité des objets Integer contenus. Autrement dit, le résultat de list.get (0) == list.get (0) n'est pas spécifié.
pburka
1
Méfiez-vous du nombre de références de méthode sur Android lors de l'ajout de bibliothèques. Bonne trouvaille cependant.
milosmns
96

Arrays.asList ne fonctionnera pas comme le prévoient certaines des autres réponses.

Ce code ne créera pas de liste de 10 entiers. Il imprimera 1 , pas 10 :

int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List lst = Arrays.asList(arr);
System.out.println(lst.size());

Cela va créer une liste d'entiers:

List<Integer> lst = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

Si vous avez déjà le tableau d'ints, il n'y a pas de moyen rapide de convertir, vous êtes mieux avec la boucle.

D'un autre côté, si votre tableau contient des objets, pas des primitives, Arrays.asList fonctionnera:

String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" };
List<String> lst = Arrays.asList(str);
Leonel
la source
2
Notez que cette liste est immuable
Danielson
51

J'ajouterai une autre réponse avec une méthode différente; pas de boucle mais une classe anonyme qui utilisera les fonctionnalités d'autoboxing:

public List<Integer> asList(final int[] is)
{
    return new AbstractList<Integer>() {
            public Integer get(int i) { return is[i]; }
            public int size() { return is.length; }
    };
}
Christoffer
la source
1
+1 c'est plus court que le mien mais le mien fonctionne pour tous les types de primitives
dfa
5
Bien que plus rapide et utilisant moins de mémoire que la création d'une liste de tableaux, le compromis est List.add () et List.remove () ne fonctionnent pas.
Stephen Denne
3
J'aime assez cette solution pour les grands tableaux avec des modèles d'accès clairsemés, mais pour les éléments fréquemment consultés, cela entraînerait de nombreuses instanciations inutiles d'Integer (par exemple, si vous avez accédé au même élément 100 fois). Vous devez également définir Iterator et encapsuler la valeur de retour dans Collections.unmodifiableList.
Adamski
@Christoffer merci. J'ai ajouté la setméthode et maintenant je peux même trier le tableau ...
freedev
39

Le plus petit morceau de code serait:

public List<Integer> myWork(int[] array) {
    return Arrays.asList(ArrayUtils.toObject(array));
}

d'où vient ArrayUtils commons-lang :)

Kannan Ekanath
la source
9
Notez simplement ArrayUtilsqu'il s'agit d'une grande bibliothèque relative pour une application Android
msysmilu
L'opération inverse est décrite ici: stackoverflow.com/a/960507/1333157 ArrayUtils.toPrimitive(...) est la clé.
ZeroOne
26

En Java 8 avec stream:

int[] ints = {1, 2, 3};
List<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, Arrays.stream(ints).boxed().toArray(Integer[]::new));

ou avec des collectionneurs

List<Integer> list =  Arrays.stream(ints).boxed().collect(Collectors.toList());
user2037659
la source
3
Pourquoi ne pas simplement utiliser un collecteur?
assylias
19

En Java 8:

int[] arr = {1,2,3};
IntStream.of(arr).boxed().collect(Collectors.toList());
Neeraj
la source
16

Si vous utilisez Java 8, nous pouvons utiliser l'API Stream pour le convertir en liste.

List<Integer> list = Arrays.stream(arr)     // IntStream 
                                .boxed()        // Stream<Integer>
                                .collect(Collectors.toList());

Vous pouvez également utiliser IntStream pour convertir également.

List<Integer> list = IntStream.of(arr) // return Intstream
                                    .boxed()        // Stream<Integer>
                                    .collect(Collectors.toList());

Il existe d'autres bibliothèques externes comme la goyave et les apaches communs également disponibles pour la convertir.

à votre santé.

Mukesh Kumar Gupta
la source
11

Il vaut également la peine de consulter ce rapport de bogue , qui a été fermé avec la raison "Pas un défaut" et le texte suivant:

"Le contrôle automatique de baies entières n'est pas un comportement spécifié, pour une bonne raison. Il peut être prohibitif pour les baies de grande taille."

Adamski
la source
7

essayez cette classe:

class PrimitiveWrapper<T> extends AbstractList<T> {

    private final T[] data;

    private PrimitiveWrapper(T[] data) {
        this.data = data; // you can clone this array for preventing aliasing
    }

    public static <T> List<T> ofIntegers(int... data) {
        return new PrimitiveWrapper(toBoxedArray(Integer.class, data));
    }

    public static <T> List<T> ofCharacters(char... data) {
        return new PrimitiveWrapper(toBoxedArray(Character.class, data));
    }

    public static <T> List<T> ofDoubles(double... data) {
        return new PrimitiveWrapper(toBoxedArray(Double.class, data));
    }  

    // ditto for byte, float, boolean, long

    private static <T> T[] toBoxedArray(Class<T> boxClass, Object components) {
        final int length = Array.getLength(components);
        Object res = Array.newInstance(boxClass, length);

        for (int i = 0; i < length; i++) {
            Array.set(res, i, Array.get(components, i));
        }

        return (T[]) res;
    }

    @Override
    public T get(int index) {
        return data[index];
    }

    @Override
    public int size() {
        return data.length;
    }
}

cas de test:

List<Integer> ints = PrimitiveWrapper.ofIntegers(10, 20);
List<Double> doubles = PrimitiveWrapper.ofDoubles(10, 20);
// etc
dfa
la source
5

Le meilleur coup:

**
 * Integer modifiable fix length list of an int array or many int's.
 *
 * @author Daniel De Leon.
 */
public class IntegerListWrap extends AbstractList<Integer> {

    int[] data;

    public IntegerListWrap(int... data) {
        this.data = data;
    }

    @Override
    public Integer get(int index) {
        return data[index];
    }

    @Override
    public Integer set(int index, Integer element) {
        int r = data[index];
        data[index] = element;
        return r;
    }

    @Override
    public int size() {
        return data.length;
    }
}
  • Support get et set.
  • Pas de duplication des données mémoire.
  • Pas de perte de temps en boucles.

Exemples:

int[] intArray = new int[]{1, 2, 3};
List<Integer> integerListWrap = new IntegerListWrap(intArray);
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3);
Daniel De León
la source
Je l'aime le plus. Mais j'utiliserais toujours la goyave pour avoir une solution simple :)
dantuch
1

Si vous êtes prêt à utiliser une bibliothèque tierce, cela fonctionnera dans les collections Eclipse :

int[] a = {1, 2, 3};
List<Integer> integers = IntLists.mutable.with(a).collect(i -> i);
Assert.assertEquals(Lists.mutable.with(1, 2, 3), integers);

Remarque: je suis un committer pour les collections Eclipse .

Donald Raab
la source
1
   /* Integer[] to List<Integer> */



        Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        List<Integer> arrList = new ArrayList<>();
        arrList.addAll(Arrays.asList(intArr));
        System.out.println(arrList);


/* Integer[] to Collection<Integer> */


    Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
    Collection<Integer> c = Arrays.asList(intArr);
Uddhav Gautam
la source
1

Et ça:

int[] a = {1,2,3}; Integer[] b = ArrayUtils.toObject(a); List<Integer> c = Arrays.asList(b);

humblefoolish
la source
1

Voici une solution:

int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Integer[] iArray = Arrays.stream(array).boxed().toArray(Integer[]::new);
System.out.println(Arrays.toString(iArray));

List<Integer> list = new ArrayList<>();
Collections.addAll(list, iArray);
System.out.println(list);

Production:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Amitabha Roy
la source
1

Voici une autre possibilité, toujours avec Java 8 Streams:

void intArrayToListOfIntegers(int[] arr, List<Integer> list) {
    IntStream.range(0, arr.length).forEach(i -> list.add(arr[i]));
}
Koray Tugay
la source
0

Voici une façon générique de convertir un tableau en ArrayList

<T> ArrayList<T> toArrayList(Object o, Class<T> type){
    ArrayList<T> objects = new ArrayList<>();
    for (int i = 0; i < Array.getLength(o); i++) {
        //noinspection unchecked
        objects.add((T) Array.get(o, i));
    }
    return objects;
}

Usage

ArrayList<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class);
Ilya Gazman
la source
0
int[] arr = { 1, 2, 3, 4, 5 };

List<Integer> list = Arrays.stream(arr)     // IntStream
                            .boxed()        // Stream<Integer>
                            .collect(Collectors.toList());

voir ça

hamidreza75
la source