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.


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);
}

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());

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...)

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);

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; }
    };
}

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 :)


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());

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());

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é.


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."


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

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);

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 .


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);

1

Et ça:

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


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]

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]));
}

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);

0
int[] arr = { 1, 2, 3, 4, 5 };

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

voir ça

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.