Jak przekonwertować int [] na List <Integer> w Javie?

382

Jak przekonwertować int[]na List<Integer>Javę?

Oczywiście jestem zainteresowany inną odpowiedzią niż robienie tego w pętli, pozycja po pozycji. Ale jeśli nie ma innej odpowiedzi, wybiorę tę jako najlepszą, aby pokazać fakt, że ta funkcja nie jest częścią Java.

pupeno
źródło
Możemy skorzystać z IntStream.Of (array) .collect (Collectors.toList)
Saroj Kumar Sahoo

Odpowiedzi:

259

Nie ma skrótu do konwersji z int[]na, List<Integer>ponieważ Arrays.asListnie zajmuje się boksem i po prostu utworzy coś, List<int[]>czego nie chcesz. Musisz stworzyć metodę użyteczności.

int[] ints = {1, 2, 3};
List<Integer> intList = new ArrayList<Integer>(ints.length);
for (int i : ints)
{
    intList.add(i);
}
willcodejavaforfood
źródło
32
Najlepiej zainicjować listę rozmiarem tablicy
David Rabinowitz
110
for (int i: ints) intList.add (i);
Stephen Denne
18
@willcodejavaforfood - David oznacza, że ​​tak jest lepiej: nowa ArrayList <Integer> (ints.length);
Stephen Denne
12
@willcodejavaforfood: zadeklarowanie rozmiaru ArrayList podczas jego tworzenia zapobiegnie konieczności wewnętrznej zmiany rozmiaru po dodaniu określonej ilości. Nie jestem pewien, czy korzyść jest niewielka, ale na pewno jest korzyść.
Grundlefleck
10
new ArrayList<Integer>() {{ for (int i : ints) add(i); }}
saka1029
350

Strumienie

W Javie 8 możesz to zrobić

int[] ints = {1,2,3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());
mikeyreilly
źródło
21
Odpowiednik: Arrays.stream (ints) .boxed (). Collect (Collectors.toList ());
njfrost
4
@njfrost Masz rację, a IntStream.of po prostu wywołuje Arrays.stream, więc poprawiłem odpowiedź zgodnie z twoją sugestią
mikeyreilly,
Z jakiegoś powodu nie wydaje się, aby zwracał oczekiwany typ wyniku w Android Studio (działa w środowisku Eclipse). Mówi, oczekiwana Lista <Liczba całkowita> znaleziona Lista <Obiekt>.
Eugenio Lopez,
Wygląda czysto i zwięźle, ale kiedy użyłem tego w przeciwieństwie do podstawowego rozwiązania dostarczonego przez @willcodejavaforfood na leetcode, wydajność programu spadła pod względem pamięci, a także czasu działania
chitresh sirohi
@chitreshsirohi, ponieważ funkcje lambda używane w strumieniach powodują, że Java tworzy anonimowe klasy.
Ashvin Sharma
175

Również z bibliotek guava ... com.google.common.primitives.Ints:

List<Integer> Ints.asList(int...)
louisgab
źródło
11
To powinna być właściwa odpowiedź. Zobacz drugie zdanie pytania: „Oczywiście jestem zainteresowany inną odpowiedzią niż robienie jej w pętli, pozycja po pozycji”.
josketres
Dziekuję Dziekuję Dziękuję! Działa również dla Longs.asList (long ...).
craastad
2
Jest tutaj kilka subtelności. Zwrócona lista używa podanej tablicy jako magazynu kopii zapasowych, więc nie należy jej mutować. Lista nie gwarantuje także tożsamości zawartych obiektów całkowitoliczbowych. Oznacza to, że wynik list.get (0) == list.get (0) nie jest określony.
pburka
1
Podczas dodawania bibliotek należy uważać na liczbę odwołań do metod na Androidzie. Dobre znalezisko.
milosmns
95

Arrays.asList nie będzie działać tak, jak oczekują niektóre inne odpowiedzi.

Ten kod nie utworzy listy 10 liczb całkowitych. Wydrukuje 1 , a nie 10 :

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

Spowoduje to utworzenie listy liczb całkowitych:

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

Jeśli masz już tablicę ints, nie ma szybkiego sposobu na konwersję, lepiej skorzystaj z pętli.

Z drugiej strony, jeśli tablica zawiera obiekty, a nie prymitywy, Arrays.asList będzie działać:

String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" };
List<String> lst = Arrays.asList(str);
Leonel
źródło
2
Zauważ, że ta lista jest niezmienna
Danielson
51

Dodam inną odpowiedź inną metodą; brak pętli, ale anonimowa klasa, która będzie korzystać z funkcji autoboxowania:

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; }
    };
}
Christoffer
źródło
1
+1 jest to krótsze niż moje, ale moje działa dla wszystkich typów prymitywów
dfa
5
Chociaż jest szybszy i zużywa mniej pamięci niż tworzenie ArrayList, kompromis polega na tym, że List.add () i List.remove () nie działają.
Stephen Denne
3
Bardzo podoba mi się to rozwiązanie dla dużych tablic z rzadkimi wzorcami dostępu, ale w przypadku często używanych elementów spowodowałoby to wiele niepotrzebnych wystąpień liczby całkowitej (np. Jeśli uzyskałeś dostęp do tego samego elementu 100 razy). Musisz także zdefiniować Iterator i zawrzeć wartość zwracaną w Collections.unmodifiableList.
Adamski
@Christoffer dzięki. Dodałem tę setmetodę i teraz mogę nawet posortować tablicę ...
freedev
39

Najmniejszy fragment kodu to:

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

skąd pochodzi ArrayUtils z commons-lang :)

Kannan Ekanath
źródło
9
Pamiętaj, ArrayUtilsże jest to względnie duża biblioteka dla aplikacji na Androida
msysmilu
Odwrotna operacja jest opisana tutaj: stackoverflow.com/a/960507/1333157 ArrayUtils.toPrimitive(...) jest kluczem.
ZeroOne
26

W Javie 8 ze strumieniem:

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

lub z kolekcjonerami

List<Integer> list =  Arrays.stream(ints).boxed().collect(Collectors.toList());
użytkownik2037659
źródło
3
Dlaczego nie po prostu użyć kolektora?
assylias
19

W Javie 8:

int[] arr = {1,2,3};
IntStream.of(arr).boxed().collect(Collectors.toList());
Neeraj
źródło
16

Jeśli używasz Java 8, możemy użyć interfejsu API strumienia, aby przekonwertować go na listę.

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

Możesz także użyć IntStream do konwersji.

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

Istnieją inne zewnętrzne biblioteki, takie jak guawa i wspólne apache, które również mogą je konwertować.

Twoje zdrowie.

Mukesh Kumar Gupta
źródło
11

Warto również sprawdzić ten raport o błędzie , który został zamknięty z powodu „Brak usterki” i następujący tekst:

„Nie bez powodu zachowanie automatycznego sprawdzania całych tablic nie jest określone. W przypadku dużych tablic może być zbyt drogie”.

Adamski
źródło
7

spróbuj tej klasy:

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

walizka testowa:

List<Integer> ints = PrimitiveWrapper.ofIntegers(10, 20);
List<Double> doubles = PrimitiveWrapper.ofDoubles(10, 20);
// etc
dfa
źródło
5

Najlepszy strzał:

**
 * 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;
    }
}
  • Wsparcie uzyskać i ustawić.
  • Brak powielania danych w pamięci.
  • Bez marnowania czasu w pętlach.

Przykłady:

int[] intArray = new int[]{1, 2, 3};
List<Integer> integerListWrap = new IntegerListWrap(intArray);
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3);
Daniel De León
źródło
Najbardziej mi się podoba. Ale nadal
używałbym
1

Jeśli jesteś otwarty na korzystanie z biblioteki innej firmy, będzie to działać w kolekcjach 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);

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse .

Donald Raab
źródło
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);
Uddhav Gautam
źródło
1

A co z tym:

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

pokorny
źródło
1

Oto rozwiązanie:

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

Wynik:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Amitabha Roy
źródło
1

Oto kolejna możliwość, znowu w przypadku strumieni Java 8:

void intArrayToListOfIntegers(int[] arr, List<Integer> list) {
    IntStream.range(0, arr.length).forEach(i -> list.add(arr[i]));
}
Koray Tugay
źródło
0

Oto ogólny sposób konwersji tablicy na 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;
}

Stosowanie

ArrayList<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class);
Ilya Gazman
źródło