다음과 같이 초기화 된 배열이 있습니다.
Element[] array = {new Element(1), new Element(2), new Element(3)};
이 배열을 ArrayList
클래스 의 객체로 변환하고 싶습니다 .
ArrayList<Element> arraylist = ???;
ArrayList
. 포스터가 구체적으로 요청했습니다.
다음과 같이 초기화 된 배열이 있습니다.
Element[] array = {new Element(1), new Element(2), new Element(3)};
이 배열을 ArrayList
클래스 의 객체로 변환하고 싶습니다 .
ArrayList<Element> arraylist = ???;
ArrayList
. 포스터가 구체적으로 요청했습니다.
답변:
new ArrayList<>(Arrays.asList(array));
new ArrayList
전화가 불필요합니다.
List<ClassName> list = Arrays.asList(array)
Arrays.asList(array)
새 ArrayList
객체에 전달하지 않고 사용 하면 목록의 크기가 고정됩니다. 를 사용하는 가장 일반적인 이유 중 하나는 ArrayList
크기를 동적으로 변경할 수 있기 때문에 제안하면이를 방지 할 수 있습니다.
주어진:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
가장 간단한 대답은 다음과 같습니다.
List<Element> list = Arrays.asList(array);
이것은 잘 작동합니다. 그러나 몇 가지주의 사항 :
ArrayList
. 그렇지 않으면을 얻습니다 UnsupportedOperationException
.asList()
은 원래 배열에 의해 지원됩니다. 원래 배열을 수정하면 목록도 수정됩니다. 놀랍습니다.java.util.ArrayList
. Arrays.asList는 실제로 다른 클래스 java.util.Arrays.ArrayList
가 아닌를 반환합니다 instanceof
. 따라서 세 번째주의 사항은 위의 상황에서 사용하려고하면 작동하지 않는다는 것입니다.
(오래된 실이지만 구아바 또는 다른 라이브러리와 다른 세부 사항을 언급하지 않은 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);
}
List
의해 반환 된 요소 Arrays.asList
는 여전히 set
요소 를 가질 수 있다는 점에서 변경 가능 하다는 점에 유의하십시오 . 구아바가없는 불변 목록에 대해서는 언급 할 수 있습니다 Collections.unmodifiableList
.
arrayToList
의 Java 1.5 이상이 잘못되었습니다. 의 목록을 String
작성하고 일반 매개 변수 유형을 사용하는 대신 지정된 배열에서 문자열을 검색하려고합니다 T
. 그 외에는 좋은 답변과 수동 방법을 포함한 유일한 사람이 +1입니다.
O(1)
이지만 불변성 때문에 예를 들어 by로 복사해야합니다 Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array)))
.
이 질문은 꽤 오래되었으므로 아무도 가장 간단한 양식을 제안하지 않았다는 사실에 놀랐습니다.
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
Java 5 Arrays.asList()
부터는 varargs 매개 변수를 사용하므로 명시 적으로 배열을 구성 할 필요가 없습니다.
List<String> a = Arrays.asList("first","second","third")
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 는 Java Collections API를 위한 편리한 팩토리 메소드를 제공합니다 . 이 불변의 static 팩토리 메소드가 내장되어 있습니다 List
, Set
그리고 Map
나중에 자바 (9)과의 인터페이스를 제공합니다.
아마도 ArrayList가 아닌 List가 필요할 것입니다. 이 경우 다음을 수행 할 수 있습니다.
List<Element> arraylist = Arrays.asList(array);
set
메소드)를 변경할 수 있으며 목록의 크기 ( add
또는 remove
요소)를 변경할 수 없습니다 !
2014 년에 거의 끝나는 또 다른 업데이트는 Java 8에서도 가능합니다.
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
이 문자가 단지 List
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Collectors.toList()
실제로는을 반환합니다 ArrayList
.
당신이 사용하는 경우 :
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
또는 구아바를. 그러나 그것이 맞지 않거나 느끼지 않는다면, 다른 우아한 줄을 대신 쓰십시오.
new ArrayList<T>(Arrays.asList(myArray));
당신이 사용하지 않는 부분 사이의 근본적인 차이점을 보지 못했습니다 . 둘 다 똑같이하고 같은 복잡성을 가지고 있습니다.
new ArrayList<T>(Arrays.asList(myArray));
같은, 그 복사본은 않습니다 asList
에 ArrayList
...
에서 Java 9
사용할 수 :
List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
다른 방법으로 변환 할 수 있습니다
List<Element> list = Arrays.asList(array);
List<Element> list = new ArrayList();
Collections.addAll(list, array);
Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));
자세한 내용은 http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html을 참조하십시오.
모두가 말했듯이 이것은 그렇게 할 것입니다
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에서는 약간 쉽습니다.
List<String> list = List.of("element 1", "element 2", "element 3");
Java 8의 스트림으로도 할 수 있습니다.
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
Collectors.toList()
를 반환합니다 ArrayList
. 그러나 이것은 java의 향후 버전에서 다를 수 있습니다. 특정 유형의 콜렉션을 Collectors.toCollection()
원할 경우 생성하려는 정확한 콜렉션 유형을 지정할 수있는 위치를 대신 사용하십시오.
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
.
이 질문에 대한 또 다른 대답이있을 수 있습니다. 메소드에
대한 선언을 보면 java.util.Collections.addAll()
다음과 같은 것을 얻을 수 있습니다.
public static <T> boolean addAll(Collection<? super T> c, T... a);
따라서이 코드는 유용합니다.
Collections.addAll(arraylist, array);
또 다른 간단한 방법은 for-each 루프를 사용하여 배열의 모든 요소를 새 ArrayList에 추가하는 것입니다.
ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
list.add(e);
배열이 기본 유형이면 주어진 답변이 작동하지 않습니다. 그러나 Java 8부터 다음을 사용할 수 있습니다.
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
char
배열에서도 작동하지 않는 것 같습니다 .
다음과 같이 Java 8에서 수행 할 수 있습니다
ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
배열을로 쉽게 변환 할 수 있습니다 ArrayList
. 우리는 Collection 인터페이스의 addAll()
방법을 사용하여 한 목록에서 다른 목록으로 내용을 복사합니다.
Arraylist arr = new Arraylist();
arr.addAll(Arrays.asList(asset));
ArrayList
의 생성자 중 하나가 ? extends Collection<T>
인수를 수락 하여 addAll
중복을 호출합니다 .
이 질문에 대한 완벽한 답이 많이 있지만 입력 내용을 추가하겠습니다.
당신이 가지고 있다고 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
배열 링크 의 목록 표현에 대한 추가 정보 .
또 다른 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);
}
}
출력은 ...
안녕하세요
세계
다음 코드를 사용하여 요소 배열을 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]);
}
이미 모든 사람이 문제에 대한 충분한 답변을 제공했습니다. 이제 모든 제안에서 요구 사항에 맞는 것을 결정해야합니다. 알아야 할 두 가지 유형의 컬렉션이 있습니다. 하나는 수정되지 않은 컬렉션이고 다른 하나는 나중에 개체를 수정할 수있는 컬렉션입니다.
여기서는 두 가지 사용 사례에 대한 간단한 예를 제공합니다.
변경할 수없는 컬렉션 생성 :: 생성 후 컬렉션 개체를 수정하지 않으려는 경우
List<Element> elementList = Arrays.asList(array)
가변 콜렉션 작성 :: 작성 후 작성된 콜렉션 오브젝트를 수정하려는 경우
List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));
List
에 의해 반환은 Arrays.asList
원래의 배열을 통해 단지 래퍼이며, 개별 항목에 액세스하고를 통해 수정 될 수 있도록 get
하고 set
. "불변"대신 "요소를 추가하거나 제거하지 않음"을 의미한다는 것을 분명히해야합니다. 이는 전혀 변경되지 않음을 의미합니다.
주어진 객체 배열 :
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
삼
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());