문제

어떻게 변환합니까? int[] ~ 안으로 List<Integer> 자바에서?

물론, 나는 항목별로 고리에서 그것을하는 것보다 다른 답변에 관심이 있습니다. 그러나 다른 대답이 없다면, 나는이 기능이 Java의 일부가 아니라는 사실을 보여주기 위해 최선의 답변을 선택할 것입니다.

도움이 되었습니까?

해결책

변환하기위한 바로 가기가 없습니다 int[] 에게 List<Integer> ~처럼 Arrays.asList 권투를 다루지 않고 List<int[]> 당신이 원하는 것이 아닙니다. 유틸리티 방법을 만들어야합니다.

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

다른 팁

스트림

Java 8에서는 이것을 할 수 있습니다

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

또한 구아바 도서관... com.google.common.primitives.ints :

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

Array.Aslist는 다른 답변 중 일부가 기대하는 것처럼 작동하지 않습니다.

이 코드는 할 것입니다 ~ 아니다 10 개의 정수 목록을 만듭니다. 인쇄됩니다 1, 아니다 10:

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

이것은 정수 목록을 만듭니다.

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

이미 INT 배열이 있다면 빠른 변환 방법이 없으면 루프가 더 좋습니다.

반면에, 배열이 프리미티브가 아닌 객체가 있으면 Array.Aslist가 작동합니다.

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

다른 방법으로 다른 대답을 추가하겠습니다. 고리는 없지만 자서전 기능을 활용하는 익명 클래스 :

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

가장 작은 코드는 다음과 같습니다.

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

어레이 틸이 커먼즈라는 곳에서 오는 곳 :)

스트림이있는 Java 8에서 :

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

또는 수집가와 함께

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

Java 8 :

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

또한 체크 아웃 할 가치가 있습니다 이 버그 보고서, "결함이 아님"과 다음 텍스트로 폐쇄되었습니다.

"전체 배열의자가 공산은 정당한 이유로 지정된 동작이 아닙니다. 큰 배열의 경우 엄청나게 비쌀 수 있습니다."

이 수업을 시도해보십시오.

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

테스트 케이스 :

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

최고의 샷 :

**
 * 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;
    }
}
  • 지원 및 설정 지원.
  • 메모리 데이터 복제가 없습니다.
  • 루프에서 시간을 낭비하지 않습니다.

예 :

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

Java 8을 사용하는 경우 스트림 API를 사용하여 목록으로 변환 할 수 있습니다.

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

intstream을 사용하여 변환 할 수도 있습니다.

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

Guava 및 Apache Commons와 같은 다른 외부 라이브러리도 있습니다.

건배.

제 3 자 라이브러리를 사용하기 위해 개방 된 경우 일식 컬렉션:

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

참고 : 저는 커밋 자입니다 일식 컬렉션.

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

이건 어때 :

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

다음은 해결책입니다.

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

산출:

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

다음은 Java 8 스트림과 함께 또 다른 가능성이 있습니다.

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

배열을 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;
}

용법

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

나는 줄을 따라 무언가가 있는지 궁금합니다 Arrays.asList(...array) 작동 할 것이다...

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top