배열에서 ArrayList 생성

StackOverflow https://stackoverflow.com/questions/157944

문제

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

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() 원래 배열로 뒷받침됩니다. 원래 배열을 수정하면 목록도 수정됩니다. 이것은 놀랍습니다.

(오래된 스레드, 그러나 Guava 또는 기타 Libs 및 기타 세부 사항을 언급하지 않은 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.

왜 구아바인가?

주요 매력은 Guava의 사용으로 유형 안전에 대한 제네릭으로 인한 혼란을 줄이는 것입니다. 공장 방법 대부분의 시간을 추론 할 수 있습니다. 그러나 Java 7이 새로운 다이아몬드 연산자와 함께 도착한 이후이 주장은 물이 적습니다.

그러나 이것이 유일한 이유는 아닙니다 (그리고 Java 7은 아직 어디에나 있지 않습니다), 속기 구문도 매우 편리하며 위에서 볼 수 있듯이 메소드 초기화기는보다 표현적인 코드를 작성할 수 있습니다. 현재 Java 컬렉션으로 2를 차지하는 하나의 구아바 호바에서 할 수 있습니다.

할 수 없다면 ...

불변의 목록

JDK를 사용하십시오 Arrays 클래스와 그 asList() 공장 방법, a Collections.unmodifiableList():

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

반환 된 유형에 유의하십시오 asList() a List 콘크리트 사용 ArrayList 구현이지만 그렇지 않습니다 java.util.ArrayList. 내부 유형으로 에뮬레이션합니다 ArrayList 그러나 실제로 전달 된 배열을 직접 참조하고 "쓰기"(수정은 배열에 반영됨)를 만듭니다.

일부를 통해 수정을 금지합니다 List 단순히 확장하는 API의 방법 AbstractList (따라서 요소를 추가하거나 제거하는 것은 지원되지 않습니다) 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);

Java 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 편의 공장 방법을 제공합니다 자바 컬렉션 API. 이 불변의 정적 공장 방법은 다음에 내장되어 있습니다 List, Set, 그리고 Map Java 9 이상의 인터페이스.

아마도 배열 목록이 아닌 목록이 필요할 것입니다. 이 경우 그냥 할 수 있습니다.

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

너 5월 만들다 그리고 채우다 두 개의 목록!큰 목록을 두 번 채우는 것은 또 다른 목록을 생성하기 때문에 원하지 않는 일입니다. 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
    }
    ....
}

위험한 면은 바로 초기 배열을 변경하면 List ! 정말로 그걸 원하시나요?그럴 수도 있고 아닐 수도 있습니다.

그렇지 않은 경우 가장 이해하기 쉬운 방법은 다음을 수행하는 것입니다.

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

그리고 배열을 만드는 일반적인 가장 새로운 방법은입니다 관찰

관찰자 : 청취자가 변경이 발생할 때 변경 사항을 추적 할 수있는 목록.

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

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

그것은 다음과 같습니다 오라클 문서

ObservableArrayList ()는 ArrayList에 의해 뒷받침되는 새로운 빈 관측형 목록을 만듭니다. ObservableArraylist (E ... 항목)는 항목이 추가 된 새로운 관찰 가능한 배열 목록을 만듭니다.

Java 9 업데이트

또한 Java 9에서는 조금 쉽습니다.

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

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

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

Java 8이므로 더 쉬운 변환 방법이 있습니다.

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(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());

배열을 쉽게 변환 할 수 있습니다 ArrayList. 우리는 컬렉션 인터페이스를 사용합니다 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의 목록보기 만 반환합니다.

// 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 솔루션 (큰 세트 사이의 답을 놓쳤을 수도 있습니다. 그렇다면 사과 드). 이것은 ArrayList를 만듭니다 (목록과 반대로) IE는 요소를 삭제할 수 있습니다.

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

출력은 ...
안녕하십니까
세계

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

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

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

따라서 여기서는 두 가지 사용 사례에 대한 짧은 예를 제시 할 것입니다.

  • 불변의 수집 생성 :: 생성 후 컬렉션 개체를 수정하고 싶지 않은 경우

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

  • Mutable Collection Creation :: 생성 후 생성 된 컬렉션 객체를 수정할 때.

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

다음 코드를 사용하여 요소 배열을 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]);
}

You can create an ArrayList using Cactoos (I'm one of the developers):

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

There is no guarantee that the object will actually be of class ArrayList. If you need that guarantee, do this:

ArrayList<String> list = new ArrayList<>(
  new StickyList<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
  )
);

Use below code

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

This is a clear way for that

ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))
라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top