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

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

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

ArrayList<Element> arraylist = ???;

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

주어진:

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()은 원래 배열에 의해 지원됩니다. 원래 배열을 수정하면 목록도 수정됩니다. 놀랍습니다.

^{(오래된 실이지만 구아바 또는 다른 라이브러리와 다른 세부 사항을 언급하지 않은 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<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

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

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

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

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

Collections.addAll(arraylist, array);

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

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

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

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

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

이 문자가 단지 List

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

당신이 사용하는 경우 :

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또는 구아바를. 그러나 그것이 맞지 않거나 느끼지 않는다면, 다른 우아한 줄을 대신 쓰십시오.

에서 Java 9사용할 수 :

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

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

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

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

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

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

다른 방법으로 변환 할 수 있습니다

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

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. 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 업데이트

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

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

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

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

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

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

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

또 다른 간단한 방법은 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());

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

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

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

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

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

당신이 가지고 있다고 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

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

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

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

또 다른 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));

주어진 객체 배열 :

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

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

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