J'essaie de convertir une ArrayList contenant des objets Integer en primitive int [] avec le morceau de code suivant, mais cela génère une erreur de temps de compilation. Est-il possible de convertir en Java?

List<Integer> x =  new ArrayList<Integer>();
int[] n = (int[])x.toArray(int[x.size()]);

Vous pouvez convertir, mais je ne pense pas qu'il y ait quelque chose de intégré pour le faire automatiquement:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    for (int i=0; i < ret.length; i++)
    {
        ret[i] = integers.get(i).intValue();
    }
    return ret;
}

(Notez que cela lèvera une NullPointerException si l'un integersou l'autre des éléments qu'il contient null.)

EDIT: Selon les commentaires, vous voudrez peut-être utiliser l'itérateur de liste pour éviter des coûts désagréables avec des listes telles que LinkedList:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    Iterator<Integer> iterator = integers.iterator();
    for (int i = 0; i < ret.length; i++)
    {
        ret[i] = iterator.next().intValue();
    }
    return ret;
}

Si vous utilisez java-8 il y a aussi une autre façon de procéder.

int[] arr = list.stream().mapToInt(i -> i).toArray();

Ce qu'il fait, c'est:

• obtenir un Stream<Integer>de la liste
• obtention d'un IntStreamen mappant chaque élément sur lui-même (fonction d'identité), déballage de la intvaleur détenue par chaque Integerobjet (fait automatiquement depuis Java 5)
• obtenir le tableau inten appelanttoArray

Vous pouvez également appeler explicitement intValuevia une référence de méthode, c'est-à-dire:

int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

Il convient également de mentionner que vous pouvez en obtenir un NullPointerExceptionsi vous avez une nullréférence dans la liste. Cela pourrait être facilement évité en ajoutant une condition de filtrage au pipeline de flux comme ceci:

                       //.filter(Objects::nonNull) also works
int[] arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray();

Exemple:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
int[] arr = list.stream().mapToInt(i -> i).toArray(); //[1, 2, 3, 4]

list.set(1, null); //[1, null, 3, 4]
arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray(); //[1, 3, 4]

Google Guava

Google Guava offre un moyen pratique de le faire en appelant Ints.toArray.

List<Integer> list = ...;
int[] values = Ints.toArray(list);

Apache Commons a une classe ArrayUtils, qui a une méthode toPrimitive () qui fait exactement cela.

import org.apache.commons.lang.ArrayUtils;
...
    List<Integer> list = new ArrayList<Integer>();
    list.add(new Integer(1));
    list.add(new Integer(2));
    int[] intArray = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));

Cependant, comme Jon l'a montré, il est assez facile de le faire vous-même au lieu d'utiliser des bibliothèques externes.

Je pense que l'itération à l'aide de l'itérateur de la liste est une meilleure idée, car list.get(i)les performances peuvent être médiocres selon la mise en œuvre de la liste:

private int[] buildIntArray(List<Integer> integers) {
    int[] ints = new int[integers.size()];
    int i = 0;
    for (Integer n : integers) {
        ints[i++] = n;
    }
    return ints;
}

utiliser Dollar devrait être assez simple:

List<Integer> list = $(5).toList(); // the list 0, 1, 2, 3, 4  
int[] array = $($(list).toArray()).toIntArray();

Je prévois d'améliorer la DSL afin de supprimer l' toArray()appel intermédiaire

Cela fonctionne bien pour moi :)

Trouvé sur https://www.techiedelight.com/convert-list-integer-array-int/

import java.util.Arrays;
import java.util.List;

class ListUtil
{
    // Program to convert list of integer to array of int in Java
    public static void main(String args[])
    {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        int[] primitive = list.stream()
                            .mapToInt(Integer::intValue)
                            .toArray();

        System.out.println(Arrays.toString(primitive));
    }
}

Cela m'étonne que nous encourageons les méthodes personnalisées ponctuelles chaque fois qu'une bibliothèque parfaitement bonne et bien utilisée comme Apache Commons a déjà résolu le problème. Bien que la solution soit triviale sinon absurde, il est irresponsable d'encourager un tel comportement en raison de la maintenance et de l'accessibilité à long terme.

Allez avec Apache Commons

Si vous utilisez des collections Eclipse , vous pouvez utiliser la collectInt()méthode pour basculer d'un conteneur d'objets vers un conteneur int primitif.

List<Integer> integers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
MutableIntList intList =
  ListAdapter.adapt(integers).collectInt(i -> i);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intList.toArray());

Si vous pouvez convertir votre ArrayListen un FastList, vous pouvez vous débarrasser de l'adaptateur.

Assert.assertArrayEquals(
  new int[]{1, 2, 3, 4, 5},
  Lists.mutable.with(1, 2, 3, 4, 5)
    .collectInt(i -> i).toArray());

Remarque: je suis un committer pour les collections Eclipse.

Java 8:

int[] intArr = Arrays.stream(integerList).mapToInt(i->i).toArray();

Arrays.setAll ()

    List<Integer> x = new ArrayList<>(Arrays.asList(7, 9, 13));
    int[] n = new int[x.size()];
    Arrays.setAll(n, x::get);

    System.out.println("Array of primitive ints: " + Arrays.toString(n));

Production:

Tableau d'entiers primitifs: [7, 9, 13]

Les mêmes œuvres pour un tableau de longou double, mais pas pour les tableaux de boolean, char, byte, shortou float. Si vous avez une liste vraiment énorme, il existe même une parallelSetAllméthode que vous pouvez utiliser à la place.

Pour moi, c'est assez bon et assez élancé pour que je ne veuille pas obtenir une bibliothèque externe ni utiliser de flux pour cela.

Lien de documentation: Arrays.setAll(int[], IntUnaryOperator)

Vous pouvez simplement le copier dans un tableau:

int[] arr = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

Pas trop de fantaisie; mais bon ça marche ...

Une solution monoligne très simple est:

Integer[] i = arrlist.stream().toArray(Integer[]::new);

Ce segment de code fonctionne pour moi, essayez ceci:

Integer[] arr = x.toArray(new Integer[x.size()]);

Il convient de mentionner ArrayList devrait être déclaré comme suit:

ArrayList<Integer> list = new ArrayList<>();

   List<Integer> list = new ArrayList<Integer>();

    list.add(1);
    list.add(2);

    int[] result = null;
    StringBuffer strBuffer = new StringBuffer();
    for (Object o : list) {
        strBuffer.append(o);
        result = new int[] { Integer.parseInt(strBuffer.toString()) };
        for (Integer i : result) {
            System.out.println(i);
        }
        strBuffer.delete(0, strBuffer.length());
    }

Integer[] arr = (Integer[]) x.toArray(new Integer[x.size()]);

accès arrcomme d'habitude int[].