배열에서 ArrayList 만들기


3596

다음과 같이 초기화 된 배열이 있습니다.

Element[] array = {new Element(1), new Element(2), new Element(3)};

이 배열을 ArrayList클래스 의 객체로 변환하고 싶습니다 .

ArrayList<Element> arraylist = ???;

49
Java9에서-> List <String> list = List.of (“Hello”,“World”,“from”,“Java”);
MarekM

18
@MarekM이 답변은을 반환하지 않으므로 잘못되었습니다 ArrayList. 포스터가 구체적으로 요청했습니다.
Dorian Grey

4
목록 인터페이스를 사용하지 않았다고 생각합니다. 가장 좋은 방법이기 때문입니다. 그러나 여기서 원한다면-new ArrayList <> (List.of (“Hello”,“World”,“from”,“Java”));
MarekM

10
요점은 인터페이스 사용에 관한 것이 아니라 요점은 솔루션에서 반환 된 목록을 수정할 수 없다는 것입니다. 그것은 더 많은 문제가 될 수 있으며 그가 ArrayList를 요청한 이유
Dorian Gray

답변:


4603
new ArrayList<>(Arrays.asList(array));

361
네. 그리고 목록을 원하는 (가장 일반적인) 경우에는 new ArrayList전화가 불필요합니다.
Calum

143
@Luron-그냥 사용List<ClassName> list = Arrays.asList(array)
Pool

248
@Calum 및 @Pool-Alex Miller의 답변에서 아래에 언급 된 것처럼 Arrays.asList(array)ArrayList객체에 전달하지 않고 사용 하면 목록의 크기가 고정됩니다. 를 사용하는 가장 일반적인 이유 중 하나는 ArrayList크기를 동적으로 변경할 수 있기 때문에 제안하면이를 방지 할 수 있습니다.
Code Jockey

130
Arrays.asList ()는 끔찍한 함수이므로 반환 값을 그대로 사용해서는 안됩니다. List 템플릿을 분리하므로 중복 된 것처럼 보이더라도 항상 여기에 표시된 형식으로 사용하십시오. 좋은 대답입니다.
Adam

83
@Adam java.util.List에 대한 javadoc을 공부하십시오. 추가 계약을 통해 UnsupportedOperationException을 발생시킬 수 있습니다. docs.oracle.com/javase/7/docs/api/java/util/… 객체 지향적 관점에서 컬렉션을 사용하기 위해 구체적인 구현을 알아야하는 것은 그리 좋지 않습니다. 프레임 워크를 단순하게 유지하기 위해 실용적인 디자인 선택이었습니다.
lbalazscs 2013

918

주어진:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

가장 간단한 대답은 다음과 같습니다.

List<Element> list = Arrays.asList(array);

이것은 잘 작동합니다. 그러나 몇 가지주의 사항 :

  1. asList에서 반환 된 목록의 크기고정되어 있습니다 . 따라서 코드의 반환 된 목록에서 요소를 추가하거나 제거하려면 새로 감싸 야합니다 ArrayList. 그렇지 않으면을 얻습니다 UnsupportedOperationException.
  2. 에서 반환 된 목록 asList()은 원래 배열에 의해 지원됩니다. 원래 배열을 수정하면 목록도 수정됩니다. 놀랍습니다.

6
두 작업의 시간 복잡성은 무엇입니까? 나는 명시 적 arraylist 구성을 사용하거나 사용하지 않고 의미합니다.
저주

35
Arrays.asList ()는 기존 배열을 래핑하여 ArrayList를 만들어 O (1)이되도록합니다.
Alex Miller

27
새로운 ArrayList ()로 줄 바꿈하면 고정 크기 목록의 모든 요소가 반복되어 새 ArrayList에 추가되므로 O (n)이됩니다.
Alex Miller

8
asList ()에 의해 리턴 된 List의 구현은 UnsupportedOperationException을 설명하는 몇 가지 List의 메소드 (add (), remove (), clear () 등)를 구현하지 않습니다. 확실히주의 사항 ...
sethro

8
질문에 "ArrayList 클래스의 객체"가 필요할 때 참조하는 클래스를 가정하는 것이 합리적이라고 생각합니다 java.util.ArrayList. Arrays.asList는 실제로 다른 클래스 java.util.Arrays.ArrayList가 아닌를 반환합니다 instanceof. 따라서 세 번째주의 사항은 위의 상황에서 사용하려고하면 작동하지 않는다는 것입니다.
Dave L.

352

(오래된 실이지만 구아바 또는 다른 라이브러리와 다른 세부 사항을 언급하지 않은 2 센트)

가능하면 구아바를 사용하십시오

구아바 길을 지적하면 가치가 있습니다.

용법

불변 목록

ImmutableList클래스와 해당 메소드 of()copyOf()팩토리 메소드를 사용하십시오 (요소는 널 (null) 일 수 없음) .

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

가변 목록

Lists클래스와 newArrayList()팩토리 메소드를 사용하십시오 .

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

다른 클래스의 다른 데이터 구조에 대해서도 비슷한 방법을 참고하십시오. Sets .

왜 구아바?

구아바 공장 방법을 사용함에 따라 유형 안전을위한 제네릭으로 인해 혼란을 줄이는 것이 주요 매력이 될 수 있습니다. 사용하면 대부분 유형을 유추 할 수 . 그러나 Java 7이 새로운 다이아몬드 연산자와 함께 도착한 이후로이 주장은 물을 덜 보유합니다.

그러나 이것이 유일한 이유는 아닙니다 (그리고 Java 7이 아직 어디에도 없습니다) : 속기 구문도 매우 편리하며 위에서 설명한 것처럼 메소드 초기화 프로그램은보다 표현력있는 코드를 작성할 수 있습니다. 하나의 구아바 호출에서 현재 Java 컬렉션으로 2를 차지합니다.


당신이 할 수 없다면 ...

불변 목록

JDK의 Arrays클래스와 asList()팩토리 메소드를 사용하십시오 Collections.unmodifiableList().

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

에 대한 반환 유형 asList()List구체적인 ArrayList구현을 사용하지만 NOT java.util.ArrayList 입니다. 내부 유형으로 에뮬레이션ArrayList 하지만 실제로 전달 된 배열을 직접 참조하고이를 "쓰기"합니다 (수정은 배열에 반영됨).

List단순히 (확장, AbstractList요소 추가 또는 제거는 지원되지 않음) 확장을 통해 일부 API 메소드를 통한 수정을 금지 하지만 호출을 통해 set()요소를 대체 할 수 있습니다. 따라서이 목록은 불변이 아니며에 대한 호출 asList()은로 묶어야합니다 Collections.unmodifiableList().

변경 가능한 목록이 필요한 경우 다음 단계를 참조하십시오.

가변 목록

위와 동일하지만 실제 래핑되어 있습니다 java.util.ArrayList.

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

교육 목적 : 좋은 수동 방법

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

27
+1 그러나에 List의해 반환 된 요소 Arrays.asList는 여전히 set요소 를 가질 수 있다는 점에서 변경 가능 하다는 점에 유의하십시오 . 구아바가없는 불변 목록에 대해서는 언급 할 수 있습니다 Collections.unmodifiableList.
Paul Bellora 2019 년

1
@haylem 귀하의 교육 목적 : 올바른 수동 방법 에 대한 귀하 arrayToList의 Java 1.5 이상이 잘못되었습니다. 의 목록을 String작성하고 일반 매개 변수 유형을 사용하는 대신 지정된 배열에서 문자열을 검색하려고합니다 T. 그 외에는 좋은 답변과 수동 방법을 포함한 유일한 사람이 +1입니다.
afsantos

Id '는 나중에 랩핑 된 배열의 변경으로 인해 변경 될 수 있으므로 "If you cant ... 여전히 O(1)이지만 불변성 때문에 예를 들어 by로 복사해야합니다 Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))).
maaartinus

232

이 질문은 꽤 오래되었으므로 아무도 가장 간단한 양식을 제안하지 않았다는 사실에 놀랐습니다.

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

Java 5 Arrays.asList()부터는 varargs 매개 변수를 사용하므로 명시 적으로 배열을 구성 할 필요가 없습니다.


7
특히List<String> a = Arrays.asList("first","second","third")
18446744073709551615

209
new ArrayList<T>(Arrays.asList(myArray));

myArray이 유형이와 동일한 지 확인하십시오 T. 예를 들어 List<Integer>의 배열에서 를 만들려고하면 컴파일러 오류가 발생합니다 int.


103

다른 방법으로 ( new ArrayList(Arrays.asList(array))성능면 에서 솔루션 과 본질적으로 동일하지만)

Collections.addAll(arraylist, array);

96

자바 9

Java 9 에서는 리터럴 List.of을 작성하기 위해 정적 팩토리 메소드를 사용할 수 있습니다 List. 다음과 같은 것 :

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

이것은 세 개의 요소를 포함 하는 불변 목록을 반환합니다 . 변경 가능한 목록 을 원하면 해당 목록을 ArrayList생성자 에게 전달하십시오 .

new ArrayList<>(List.of(// elements vararg))

JEP 269 : 컬렉션의 편의 팩토리 메소드

JEP 269Java Collections API를 위한 편리한 팩토리 메소드를 제공합니다 . 이 불변의 static 팩토리 메소드가 내장되어 있습니다 List, Set그리고 Map나중에 자바 (9)과의 인터페이스를 제공합니다.


List.of ()는 원래 질문에서 요청한대로 java.util.ArrayList의 인스턴스를 리턴하지 않습니다. 따라서 두 번째 옵션 만 유효한 답변입니다.
tquadrat

84

아마도 ArrayList가 아닌 List가 필요할 것입니다. 이 경우 다음을 수행 할 수 있습니다.

List<Element> arraylist = Arrays.asList(array);

8
그것은 원래의 입력 배열에 의해 뒷받침되므로, 아마도 새로운 ArrayList로 랩핑하고 싶을 것입니다.
Bill the Lizard

16
이 솔루션에주의하십시오. 당신이 보면, 배열은 진정한 java.util.ArrayList를 반환하지 않습니다. 필수 메소드를 구현하는 내부 클래스를 리턴하지만 목록에서 멤버를 변경할 수 없습니다. 배열 주위의 래퍼 일뿐입니다.
Mikezx6r

1
당신은 ArrayList를 <요소>로 목록 <요소> 항목을 캐스트 할 수 있습니다
monksy

12
@ Mikezx6r : 약간의 수정 : 고정 크기 목록입니다. 목록의 요소 ( set메소드)를 변경할 수 있으며 목록의 크기 ( add또는 remove요소)를 변경할 수 없습니다 !
user85421 2009

1
그렇습니다.주의해야 할 것은 목록으로하고 싶은 일에 달려 있다는 것입니다. OP가 단순히 요소를 반복하고 싶다면 배열을 전혀 변환 할 필요가 없다는 점은 주목할 가치가 있습니다.
PaulMurrayCbr

69

2014 년에 거의 끝나는 또 다른 업데이트는 Java 8에서도 가능합니다.

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

이 문자가 단지 List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

8
구현에 의존하지 않는 것이 가장 좋지만 Collectors.toList()실제로는을 반환합니다 ArrayList.
bcsb1001

Stream.of (...)의 잘못된 사용; 하나의 요소 스트림을 만듭니다. 대신 Arrays.stream을 사용하십시오
Patrick Parker

나는 그렇게 생각하지 않지만 두 가지 옵션은 유효하지만 Arrays.stream은 'start', 'end'args가있는 과부하 방법을 사용하여 고정 크기로 만들 수 있기 때문에 약간 '더 나은'것입니다. 또한보십시오 : stackoverflow.com/a/27888447/2619091
whyem

41

당신이 사용하는 경우 :

new ArrayList<T>(Arrays.asList(myArray));

당신 두 목록을 작성 하고 채울 있습니다 ! 큰 목록을 두 번 채우는 Object[]것은 용량을 확장해야 할 때마다 다른 배열 을 생성하기 때문에 원하지 않는 일 입니다.

다행히도 JDK 구현은 빠르며 Arrays.asList(a[])매우 잘 수행됩니다. Object [] 데이터가 직접 배열을 가리키는 Arrays.ArrayList라는 일종의 ArrayList를 만듭니다.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

위험한 측면은 초기 배열을 변경하면 목록을 변경한다는 것입니다!당신은 그것을 정말로 확신합니까? 아마 그렇습니다.

그렇지 않은 경우 가장 이해하기 쉬운 방법은 다음과 같습니다.

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

또는 @glglgl에서 말했듯이 다음과 같이 다른 독립 ArrayList를 만들 수 있습니다.

new ArrayList<T>(Arrays.asList(myArray));

내가 사용하는 사랑 Collections, Arrays또는 구아바를. 그러나 그것이 맞지 않거나 느끼지 않는다면, 다른 우아한 줄을 대신 쓰십시오.


1
나는 대답의 끝에서 당신의 루프와 new ArrayList<T>(Arrays.asList(myArray));당신이 사용하지 않는 부분 사이의 근본적인 차이점을 보지 못했습니다 . 둘 다 똑같이하고 같은 복잡성을 가지고 있습니다.
glglgl

컬렉션 하나는 배열의 시작 부분에 포인터를 만듭니다. 내 루프는 많은 포인터를 만듭니다 : 각 배열 구성원마다 하나씩. 따라서 원래 배열이 변경되면 내 포이 너는 여전히 이전 값으로 향하게됩니다.
Nicolas Zozol

1
new ArrayList<T>(Arrays.asList(myArray));같은, 그 복사본은 않습니다 asListArrayList...
glglgl

37

에서 Java 9사용할 수 :

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

이것은 명시 적으로 요청되었으므로 ArrayList가 아닙니다.
Dorian Grey

33

질문에 따르면 java 1.7을 사용하는 대답은 다음과 같습니다.

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

그러나 항상 인터페이스를 사용하는 것이 좋습니다.

List<Element> arraylist = Arrays.<Element>asList(array);

30
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 


21

모두가 말했듯이 이것은 그렇게 할 것입니다

 new ArrayList<>(Arrays.asList("1","2","3","4"));

배열을 만드는 가장 일반적인 최신 방법은 observableArrays입니다.

ObservableList : 청취자가 변경 사항이 발생할 때이를 추적 할 수있는 목록입니다.

Java SE의 경우 시도해 볼 수 있습니다

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

그에 따르면 Oracle Docs

observableArrayList () arraylist에 의해 지원되는 새로운 빈 관찰 가능 목록을 만듭니다. observableArrayList (E ... items) 항목이 추가 된 새로운 관찰 가능 배열 목록을 만듭니다.

Java 9 업데이트

또한 Java 9에서는 약간 쉽습니다.

List<String> list = List.of("element 1", "element 2", "element 3");

20

Java 8부터는 쉽게 변환 할 수있는 방법이 있습니다.

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

18

Java 8의 스트림으로도 할 수 있습니다.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

3
현재 자바 (8) , Collectors.toList()를 반환합니다 ArrayList. 그러나 이것은 java의 향후 버전에서 다를 수 있습니다. 특정 유형의 콜렉션을 Collectors.toCollection()원할 경우 생성하려는 정확한 콜렉션 유형을 지정할 수있는 위치를 대신 사용하십시오.
라자 Anbazhagan

14
  1. Arrays.asList()메소드 의 정의를 보면 다음과 같은 것을 얻을 수 있습니다.

     public static <T> List<T> asList(T... a) //varargs are of T type. 

    따라서 다음 arraylist과 같이 초기화 할 수 있습니다 .

     List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

    참고 : 각각 new Element(int args)은 개별 객체로 취급되며로 전달 될 수 있습니다 var-args.

  2. 이 질문에 대한 또 다른 대답이있을 수 있습니다. 메소드에
    대한 선언을 보면 java.util.Collections.addAll()다음과 같은 것을 얻을 수 있습니다.

    public static <T> boolean addAll(Collection<? super T> c, T... a);

    따라서이 코드는 유용합니다.

    Collections.addAll(arraylist, array);

10

또 다른 간단한 방법은 for-each 루프를 사용하여 배열의 모든 요소를 ​​새 ArrayList에 추가하는 것입니다.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

10

배열이 기본 유형이면 주어진 답변이 작동하지 않습니다. 그러나 Java 8부터 다음을 사용할 수 있습니다.

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

이 솔루션은 char배열에서도 작동하지 않는 것 같습니다 .
PixelMaster

8

다음과 같이 Java 8에서 수행 할 수 있습니다

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

1
캐스트는 매우 위험 해 보이기 때문에 하향 투표되었습니다. 아무것도 돌려주지 않는리스트의 형태가 실제로는, javadoc가 「반환 된리스트의 형태, 변경 가능성, 직렬화 가능성 또는 thread 안전성에 대한 보증은 없다」라고하는 ArrayList 인 것을 지정합니다.
Dorian Grey

1
명시 적으로 ArrayList를 작성하려면 다음을 시도하십시오.ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Dorian Grey

8

배열을로 쉽게 변환 할 수 있습니다 ArrayList. 우리는 Collection 인터페이스의 addAll()방법을 사용하여 한 목록에서 다른 목록으로 내용을 복사합니다.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

이것은 9 살짜리 대답보다 덜 효율적입니다.
AjahnCharles

2
ArrayList의 생성자 중 하나가 ? extends Collection<T>인수를 수락 하여 addAll중복을 호출합니다 .
Tamoghna Chowdhury

7

이 질문에 대한 완벽한 답이 많이 있지만 입력 내용을 추가하겠습니다.

당신이 가지고 있다고 Element[] array = { new Element(1), new Element(2), new Element(3) };

다음과 같은 방법으로 새 ​​ArrayList를 만들 수 있습니다

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

그리고 ArrayList의 모든 작업을 잘 지원합니다.

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

그러나 다음 작업은 실제 ArrayList가 아닌 ArrayList의 List 뷰만 반환합니다.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

따라서 ArrayList 작업을 수행하려고 할 때 오류가 발생합니다.

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

배열 링크 의 목록 표현에 대한 추가 정보 .


7

가장 간단한 방법은 다음 코드를 추가하는 것입니다. 시도하고 테스트했습니다.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

7

또 다른 Java8 솔루션 (대형 세트 중 답변을 놓쳤을 수 있습니다. 그렇다면 사과드립니다). 이것은 List와 반대로 ArrayList를 생성합니다. 즉, 요소를 삭제할 수 있습니다

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

출력은 ...
안녕하세요
세계


7

다음 코드를 사용하여 요소 배열을 ArrayList로 변환하십시오.

Element[] array = {new Element(1), new Element(2), new Element(3)};

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}

5

이미 모든 사람이 문제에 대한 충분한 답변을 제공했습니다. 이제 모든 제안에서 요구 사항에 맞는 것을 결정해야합니다. 알아야 할 두 가지 유형의 컬렉션이 있습니다. 하나는 수정되지 않은 컬렉션이고 다른 하나는 나중에 개체를 수정할 수있는 컬렉션입니다.

여기서는 두 가지 사용 사례에 대한 간단한 예를 제공합니다.

  • 변경할 수없는 컬렉션 생성 :: 생성 후 컬렉션 개체를 수정하지 않으려는 경우

    List<Element> elementList = Arrays.asList(array)

  • 가변 콜렉션 작성 :: 작성 후 작성된 콜렉션 오브젝트를 수정하려는 경우

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));


List <Element> elementList = Arrays.asList (array)는 원래 배열을 래퍼로 만들어 원래 배열을 List로 사용할 수있게합니다. 따라서 랩퍼 오브젝트가 작성되므로 원래 배열에서 아무것도 복사되지 않습니다. 따라서 요소 추가 또는 제거와 같은 작업은 허용되지 않습니다.
Priyanka

3
당신의 "불변의 컬렉션"정말 불변 아니라고 주 - List에 의해 반환은 Arrays.asList원래의 배열을 통해 단지 래퍼이며, 개별 항목에 액세스하고를 통해 수정 될 수 있도록 get하고 set. "불변"대신 "요소를 추가하거나 제거하지 않음"을 의미한다는 것을 분명히해야합니다. 이는 전혀 변경되지 않음을 의미합니다.
Tamoghna Chowdhury

5

주어진 객체 배열 :

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

배열을 목록으로 변환 :

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

배열을 ArrayList로 변환

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

배열을 LinkedList로 변환

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

인쇄 목록 :

    list.forEach(element -> {
        System.out.println(element.i);
    });

산출

1

2


4

Java 8의 Arrays 클래스는 기본 배열과 Object 배열을 모두 허용하는 오버로드 된 버전이있는 stream () 메소드를 제공합니다.

/**** Converting a Primitive 'int' Array to List ****/

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

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());

3

아래 코드는이 작업을 수행하는 좋은 방법으로 보입니다.

new ArrayList<T>(Arrays.asList(myArray));
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.