Nasıl dönüştürebilirim int[]içine List<Integer>Java?

Tabii ki, bir döngüde, her bir öğe için yapmaktan başka bir cevapla ilgileniyorum. Ama başka bir cevap yoksa, bu işlevin Java'nın bir parçası olmadığını göstermek için en iyisini seçeceğim.

Aralarından dönüştürmek için hiçbir kısayoldur int[]için List<Integer>olduğu gibi Arrays.asListboks ile uğraşmaz ve sadece yaratacak List<int[]>istediğini olmadığı. Bir yardımcı program yapmak zorundasınız.

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

Canlı Yayınlar

Java 8'de bunu yapabilirsiniz

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

Ayrıca guava kütüphanelerinden ... com.google.common.primitives.Ints:

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

Arrays.asList diğer cevapların beklediği gibi çalışmaz.

Bu kod olacak değil 10 tamsayılar bir liste oluşturmak. 10 değil 1 yazdıracaktır :

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

Bu bir tamsayı listesi oluşturur:

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

Zaten bir dizi diziniz varsa, dönüştürmenin hızlı bir yolu yoktur, döngüden daha iyi olursunuz.

Öte yandan, dizinizde temel öğeler değil, Nesneler varsa, Arrays.asList çalışacaktır:

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

Farklı bir yöntemle başka bir cevap ekleyeceğim; döngü yok ama otomatik boks özelliklerini kullanacak anonim bir sınıf:

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

En küçük kod parçası:

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

ArrayUtils, commons-lang'den geliyor :)

Akışlı Java 8'de:

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

veya Koleksiyoncularla

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

Java 8'de:

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

Java 8 kullanıyorsanız, akış API'sini bir listeye dönüştürmek için kullanabiliriz.

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

Dönüştürmek için IntStream'i de kullanabilirsiniz.

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

Guava ve apache ortakları gibi diğer harici kütüphaneler de dönüştürülebilir.

şerefe.

Ayrıca " Hata değil" ve şu metin ile kapatılan bu hata raporunu da incelemeye değer :

"Tüm dizilerin otomatik olarak bokslanması iyi bir nedenden ötürü belirli bir davranış değildir. Büyük diziler için çok pahalı olabilir."

bu sınıfa bir şans verin:

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

test durumu:

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

En iyi atış:

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

• Destek alma ve ayarlama.
• Bellek verisi çoğaltması yok.
• Döngülerde zaman kaybı yok.

Örnekler:

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

Üçüncü taraf bir kütüphane kullanmaya açıksanız, Eclipse Koleksiyonlarında bu çalışır :

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

Not: Eclipse Collections için bir komisyoncuyum .

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

Peki buna ne dersin:

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

İşte bir çözüm:

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

Çıktı:

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

Yine Java 8 Streams ile başka bir olasılık daha var:

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

Diziyi ArrayList'e dönüştürmenin genel bir yolu

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

kullanım

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

int[] arr = { 1, 2, 3, 4, 5 };

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

bkz bu