Come convertire int [] nella lista <Integer> in Java?

Question

Come convertire int[] in List<Integer> in Java?

Naturalmente, sono interessato a qualsiasi altra risposta rispetto a farlo in un ciclo, articolo per articolo. Ma se non c'è altra risposta, la sceglierò come la migliore per mostrare il fatto che questa funzionalità non fa parte di Java.

Answer 1

non ci sono scorciatoie per la conversione da int[] a List<Integer> come Arrays.asList non si occupa con la boxe e sarà solo creare un List<int[]> che non è ciò che si desidera. Devi fare un metodo di utilità.

int[] ints = {1, 2, 3}; 
List<Integer> intList = new ArrayList<Integer>(); 
for (int i : ints) 
{ 
    intList.add(i); 
} 

Answer 2

È anche la pena di verificare this bug report, che è stato chiuso con la ragione "Non è un difetto" ed il testo seguente:.

comportamento

"Autoboxing di intere matrici non è specificato, a ragione Può essere proibitivamente costoso per i grandi array ".

Answer 3

Arrays.asList non funzionerà come previsto da alcune delle altre risposte.

Questo codice sarà non creare un elenco di 10 numeri interi. Sarà stampata , non :

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

Questo creerà una lista di interi:

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

Se avete già l'array di int, non v'è modo veloce per convertire , stai meglio con il ciclo.

D'altra parte, se la matrice ha oggetti, non primitive in esso, Arrays.asList funzionerà:

String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" }; 
List<String> lst = Arrays.asList(str); 

Answer 4

dare una prova di questa 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; 
    } 
} 

TestCase:

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

Answer 5

Aggiungerò un'altra risposta con un metodo diverso; nessun ciclo ma una classe anonima che utilizzerà le caratteristiche 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; } 
    }; 
} 

Answer 6

Il pezzo più piccolo del codice sarebbe:

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

dove ArrayUtils proviene da commons-lang :)

Answer 7

anche da guava libraries ... com.google.common.primitives.Ints:

List<Integer> Ints.asList(int...) 

Answer 8

Il colpo migliore:

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

• Supporto ottenere e impostare.
• Nessuna duplicazione dei dati di memoria.
• Nessuna perdita di tempo nei loop.

Esempi:

int[] intArray = new int[]{1, 2, 3}; 
List<Integer> integerListWrap = new IntegerListWrap(intArray); 
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3); 

Answer 9

In Java 8 con flusso:

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

o con collettori

List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Answer 10

in Java 8 è possibile farlo

int[] ints = {1,2,3}; 
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Answer 11

Ecco un modo generico per convertire array 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; 
} 

Uso

ArrayList<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class); 

Answer 12

Se siete aperti a utilizzare una libreria di terze parti, questo sistema funziona in Eclipse Collections:

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

Nota: I am a committer per Eclipse Collections.

Answer 13

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

Answer 14

In Java 8:

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