Làm cách nào để chuyển đổi int[]thành List<Integer>Java?

Tất nhiên, tôi quan tâm đến bất kỳ câu trả lời nào khác ngoài việc thực hiện nó trong một vòng lặp, từng mục. Nhưng nếu không có câu trả lời nào khác, tôi sẽ chọn câu trả lời đó là tốt nhất để cho thấy thực tế rằng chức năng này không phải là một phần của Java.

Không có phím tắt để chuyển đổi từ int[]tới List<Integer>như Arrays.asListkhông đối phó với boxing và chỉ sẽ tạo ra một List<int[]>mà không phải là những gì bạn muốn. Bạn phải làm một phương pháp tiện ích.

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

Dòng

Trong Java 8, bạn có thể làm điều này

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

Cũng từ thư viện ổi ... com.google.common.primologists.Ints:

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

Arrays.asList sẽ không hoạt động như một số câu trả lời khác mong đợi.

Mã này sẽ không tạo danh sách 10 số nguyên. Nó sẽ in 1 , không phải 10 :

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

Điều này sẽ tạo ra một danh sách các số nguyên:

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

Nếu bạn đã có mảng ints, không có cách nhanh chóng để chuyển đổi, tốt hơn hết là bạn nên sử dụng vòng lặp.

Mặt khác, nếu mảng của bạn có Đối tượng, không phải là nguyên thủy trong đó, Arrays.asList sẽ hoạt động:

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

Tôi sẽ thêm một câu trả lời khác bằng một phương pháp khác; không có vòng lặp nhưng một lớp ẩn danh sẽ sử dụng các tính năng tự động đóng hộp:

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

Đoạn mã nhỏ nhất sẽ là:

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

trong đó ArrayUtils đến từ commons-lang :)

Trong Java 8 với luồng:

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

hoặc với người sưu tầm

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

Trong Java 8:

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

Nếu bạn đang sử dụng java 8, chúng tôi có thể sử dụng API luồng để chuyển đổi nó thành một danh sách.

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

Bạn cũng có thể sử dụng IntStream để chuyển đổi.

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

Có thư viện bên ngoài khác như ổi và apache commons cũng có sẵn chuyển đổi nó.

chúc mừng

Cũng đáng kiểm tra báo cáo lỗi này , đã bị đóng với lý do "Không phải là lỗi" và văn bản sau:

"Autoboxing của toàn bộ mảng không phải là hành vi được chỉ định, vì lý do chính đáng. Nó có thể rất tốn kém cho các mảng lớn."

hãy thử với lớp này:

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

thử nghiệm:

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

Bức ảnh đẹp nhất:

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

• Hỗ trợ lấy và thiết lập.
• Không trùng lặp dữ liệu bộ nhớ.
• Không lãng phí thời gian trong các vòng lặp.

Ví dụ:

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

Nếu bạn mở để sử dụng thư viện bên thứ ba, điều này sẽ hoạt động trong Bộ sưu tập 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);

Lưu ý: Tôi là người đi làm cho Bộ sưu tập Eclipse .

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

Cái này thì sao:

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

Đây là một giải pháp:

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

Đầu ra:

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

Đây là một khả năng khác, một lần nữa với Luồng Java 8:

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

Đây là một cách chung để chuyển đổi mảng thành 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;
}

Sử dụng

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

xem cái này