Come convertire int [] in List in Java?

Question

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

Naturalmente, io sono interessato a qualsiasi altra risposta che farlo in un ciclo, voce per voce. Ma se non c'è altra risposta, Prenderò che uno come il migliore per dimostrare il fatto che questa funzionalità non è parte di Java.

Answer 1

Non ci sono scorciatoie per la conversione da int[] a List<Integer> come Arrays.asList non tratta con la boxe e sarà solo creare un List<int[]> che non è quello 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

Streams

In Java 8 si può fare questo

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

Answer 3

Anche da librerie guava ... com.google.common.primitives.Ints:

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

Answer 4

Arrays.asList non funzionerà come alcune delle altre risposte si aspettano.

Questo codice non creare una lista di 10 numeri interi. Si stamperà 1 , non 10 :

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 hai già l'array di int, non c'è modo rapido per convertire, si sta 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 5

io aggiungo 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 viene da commons-lang:)

Answer 7

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 8

In Java 8:

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

Answer 9

E 'anche la pena di verificare questo bug report, che è stato chiuso con la ragione "Non è un difetto" e il seguente testo:

"Autoboxing di intere matrici non è specificato il comportamento, per una buona ragione. Può essere proibitivo per grandi array ".

Answer 10

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 11

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.
• Nessun duplicazione dei dati di memoria.
• Nessun perdite di tempo in loop.

Esempi:

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

Answer 12

Se si utilizza Java 8, siamo in grado di utilizzare l'API flusso per convertirlo in un elenco.

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

È inoltre possibile utilizzare l'IntStream per convertire pure.

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

Ci sono altri libreria esterna come guava e Apache Commons  disponibile anche convertirlo.

applausi.

Answer 13

Se siete aperti a utilizzare una libreria di terze parti, questo funzionerà in Eclipse Collezioni :

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: Sono un committer per Eclipse Collezioni

Answer 14

   /* 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 15

Che dire di questo:

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

Answer 16

Ecco una soluzione:

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

Output:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Answer 17

Ecco un'altra possibilità, ancora una volta con Java 8 Streams:

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

Answer 18

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 19

Mi chiedo se qualcosa sulla falsariga di Arrays.asList(...array) avrebbe funzionato ...