Comment convertir List en int en Java?

Ceci est similaire à cette question: Comment convertir int [] en Integer [] en Java?

Je suis nouveau à Java. Comment puis-je convertir un List en int[] en Java? Je suis confus car List.toArray() renvoie en fait un Object[] , qui peut être converti en Integer[] ou en int[] .

En ce moment, j’utilise une boucle pour le faire:

 int[] toIntArray(List list){ int[] ret = new int[list.size()]; for(int i = 0;i < ret.length;i++) ret[i] = list.get(i); return ret; } 

Je suis sûr qu’il y a un meilleur moyen de le faire.

Malheureusement, je ne crois pas qu’il y ait vraiment une meilleure façon de le faire en raison de la nature de la gestion par Java des types primitifs, de la boxe, des tableaux et des génériques. En particulier:

  • List.toArray ne fonctionnera pas car il n’y a pas de conversion de Integer à int
  • Vous ne pouvez pas utiliser int comme argument de type pour les génériques, il faudrait donc qu’il s’agisse d’une méthode spécifique à un int (ou à une méthode qui utilise la reflection pour faire de la supercherie).

Je crois qu’il existe des bibliothèques qui ont des versions générées automatiquement de ce type de méthode pour tous les types primitifs (c.-à-d. Qu’il y a un modèle qui est copié pour chaque type). C’est moche, mais c’est comme ça que j’ai peur 🙁

Même si la classe Arrays est sortie avant l’arrivée des génériques en Java, elle devrait toujours inclure toutes les surcharges horribles si elle était introduite aujourd’hui (en supposant que vous souhaitiez utiliser des tableaux primitifs).

Personne n’a encore mentionné les stream ajoutés à Java 8, alors voici:

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

Processus de pensée:

  • simple Stream#toArray retourne Object[] , donc ce n’est pas ce que nous voulons. Également Stream#toArray(IntFunction generator) ne fait pas ce que nous voulons, car le type générique A ne peut pas représenter int primitif
  • Il serait donc intéressant d’avoir un stream capable de gérer le type primitif int , car sa méthode toArray probablement aussi int[] array (renvoyer quelque chose d’autre comme Object[] ou même Integer[] encadré Integer[] serait anormal ici). Et heureusement, Java 8 a un tel stream: IntStream
  • Il ne rest donc plus qu’à trouver comment convertir notre Stream (qui sera renvoyé de list.stream() ) à ce shiny IntStream . Ici, la méthode mapToInt vient à la rescousse. Tout ce que nous devons faire est de fournir un mappage de Integer à int . Nous pourrions utiliser quelque chose comme Integer#getValue qui renvoie int :

    mapToInt( (Integer i) -> i.intValue())

    (ou si quelqu’un préfère mapToInt(Integer::intValue) )

    mais un code similaire peut être généré en utilisant unboxing, car le compilateur sait que le résultat de ce lambda doit être int (lambda dans mapToInt est une implémentation de l’interface ToIntFunction qui attend la méthode body pour int applyAsInt(T value) qui doit renvoyer int ).

    Donc, nous pouvons simplement écrire

    mapToInt((Integer i)->i)

    ou plus simple (puisque le type Integer i peut être déduit par le compilateur car List#stream() renvoie Stream )

    mapToInt(i -> i)

En plus de Commons Lang, vous pouvez le faire avec la méthode de Ints.toArray(Collection collection) :

 List list = ... int[] ints = Ints.toArray(list); 

Cela vous évite d’avoir à faire la conversion de tableau intermédiaire que l’équivalent de Commons Lang exige vous-même.

La manière la plus simple de procéder consiste à utiliser Apache Commons Lang . Il a une classe pratique ArrayUtils qui peut faire ce que vous voulez. Utilisez la méthode toPrimitive avec la surcharge pour un tableau d’ Integer s.

 List myList; ... assign and fill the list int[] intArray = ArrayUtils.toPrimitive(myList.toArray(new Integer[myList.size()])); 

De cette façon, vous ne réinventez pas la roue. Commons Lang a beaucoup de choses utiles que Java a laissées de côté. Ci-dessus, j’ai choisi de créer une liste Integer de la bonne taille. Vous pouvez également utiliser un tableau Integer statique de longueur 0 et laisser Java allouer un tableau de la bonne taille:

 static final Integer[] NO_INTS = new Integer[0]; .... int[] intArray2 = ArrayUtils.toPrimitive(myList.toArray(NO_INTS)); 
 int[] toIntArray(List list) { int[] ret = new int[list.size()]; int i = 0; for (Integer e : list) ret[i++] = e; return ret; } 

Légère modification de votre code pour éviter l’indexation de listes coûteuse (car une liste n’est pas nécessairement une liste de tableaux, mais pourrait être une liste chaînée, pour laquelle l’access aléatoire est coûteux)

Java 8 nous a fourni un moyen simple de le faire via des stream …

En utilisant la fonction collections stream() et en mappant sur ints, vous obtenez un IntStream. Avec IntStream nous pouvons appeler toArray () qui nous donne int []

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

à int []

à IntStream

Voici le code de ligne unique Java 8 pour cela

 public int[] toIntArray(List intList){ return intList.stream().mapToInt(Integer::intValue).toArray(); } 

Je vais en jeter un autre ici. J’ai remarqué plusieurs utilisations des boucles for, mais vous n’avez même pas besoin de rien dans la boucle. Je mentionne cela uniquement parce que la question initiale essayait de trouver un code moins verbeux.

 int[] toArray(List list) { int[] ret = new int[ list.size() ]; int i = 0; for( Iterator it = list.iterator(); it.hasNext(); ret[i++] = it.next() ); return ret; } 

Si Java permettait plusieurs déclarations dans une boucle comme C ++, nous pourrions aller plus loin et faire pour (int i = 0, itter it it …

En fin de compte (cette partie n’est que mon avis), si vous avez une fonction ou une méthode d’aide pour faire quelque chose pour vous, il suffit de la configurer et de l’oublier. Ce peut être une doublure ou dix; si vous ne le regardez plus, vous ne saurez pas la différence.

Cette boucle simple est toujours correcte! pas de bugs

  int[] integers = new int[myList.size()]; for (int i = 0; i < integers.length; i++) { integers[i] = myList.get(i); } 

Si vous mappez simplement un Integer sur un int vous devriez envisager d’ utiliser le parallélisme , car votre logique de mappage ne s’appuie sur aucune variable en dehors de sa scope.

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

Juste être conscient de cela

Notez que le parallélisme n’est pas automatiquement plus rapide que l’exécution des opérations en série, bien que cela puisse être le cas si vous avez suffisamment de cœurs de données et de processeurs. Bien que les opérations d’agrégation vous permettent de mettre en œuvre plus facilement le parallélisme, il vous incombe toujours de déterminer si votre application est adaptée au parallélisme.


Il existe deux manières de mapper les entiers à leur forme primitive:

  1. Via une fonction ToIntFunction .

     mapToInt(Integer::intValue) 
  2. Via un unboxing explicite avec une expression lambda.

     mapToInt(i -> i.intValue()) 
  3. Via un unboxing implicite (auto-) avec une expression lambda.

     mapToInt(i -> i) 

Étant donné une liste avec une valeur null

 List list = Arrays.asList(1, 2, null, 4, 5); 

Voici trois options pour gérer null :

  1. Filtrez les valeurs null avant le mappage.

     int[] arr = list.parallelStream().filter(Objects::nonNull).mapToInt(Integer::intValue).toArray(); 
  2. Mappez les valeurs null sur une valeur par défaut.

     int[] arr = list.parallelStream().map(i -> i == null ? -1 : i).mapToInt(Integer::intValue).toArray(); 
  3. Manipulez null dans l’expression lambda.

     int[] arr = list.parallelStream().mapToInt(i -> i == null ? -1 : i.intValue()).toArray(); 
 int[] ret = new int[list.size()]; Iterator iter = list.iterator(); for (int i=0; iter.hasNext(); i++) { ret[i] = iter.next(); } return ret; 

Il n’y a vraiment aucun moyen de “doubler” ce que vous essayez de faire car toArray retourne un Object [] et vous ne pouvez pas lancer Object [] vers int [] ou Integer [] vers int []

essayez aussi Dollar ( cochez cette révision ):

 import static com.humaorie.dollar.Dollar.* ... List source = ...; int[] ints = $(source).convert().toIntArray(); 

Avec Eclipse Collections , vous pouvez effectuer les opérations suivantes si vous avez une liste de type java.util.List :

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

Si vous avez déjà un type de collections Eclipse comme MutableList , vous pouvez effectuer les opérations suivantes:

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

Note: je suis committer pour les collections Eclipse

Je vous recommande d’utiliser l’implémentation squelettique List partir de l’API des collections java, cela semble très utile dans ce cas particulier:

 package mypackage; import java.util.AbstractList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class Test { //Helper method to convert int arrays into Lists static List intArrayAsList(final int[] a) { if(a == null) throw new NullPointerException(); return new AbstractList() { @Override public Integer get(int i) { return a[i];//autoboxing } @Override public Integer set(int i, Integer val) { final int old = a[i]; a[i] = val;//auto-unboxing return old;//autoboxing } @Override public int size() { return a.length; } }; } public static void main(final Ssortingng[] args) { int[] a = {1, 2, 3, 4, 5}; Collections.reverse(intArrayAsList(a)); System.out.println(Arrays.toSsortingng(a)); } } 

Attention aux inconvénients de boxe / unboxing

À partir de Java 8, cela peut être facilement réalisé en utilisant l’ Stream API

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

Si vous souhaitez avoir plus d’informations sur la façon dont ce processus est terminé, merci de vous redirect vers ce lien http://www.techiedelight.com/convert-stream-array-java/#2

En utilisant un lambda, vous pouvez le faire (comstackr en jdk lambda):

 public static void main(Ssortingng ars[]) { TransformService transformService = (inputs) -> { int[] ints = new int[inputs.size()]; int i = 0; for (Integer element : inputs) { ints[ i++ ] = element; } return ints; }; List inputs = new ArrayList(5) { {add(10); add(10);} }; int[] results = transformService.transform(inputs); } public interface TransformService { int[] transform(List inputs); }