어레이에서 Array List를 만듭니다.

어레이에서 Array List를 만듭니다.

다음과 같이 초기화된 어레이가 있습니다.

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

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

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, 당신은 그러,, ......... an an...를 받게 될 것이다UnsupportedOperationException.
2. 되었다.asList()는 원래 어레이에 의해 백업됩니다.원래 어레이를 수정하면 목록도 수정됩니다.이것은 놀랄지도 모른다.

^{(오래된 스레드, 단 2센트, 구아바, 기타 리브 및 기타 세부 사항은 언급되지 않음)}

가능하면 Guava 사용

Guava의 방법을 지적할 필요가 있습니다.이 방법은, 이러한 쉐나니건을 큰폭으로 심플하게 합니다.

사용.

불변 리스트의 경우

클래스 및 해당 및 공장 출하 시 메서드를 사용합니다.

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

가변 리스트의 경우

클래스 및 해당 공장 출하 시 메서드를 사용합니다.

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

다른 클래스의 다른 데이터 구조(예: )에 대해서도 같은 메서드에 주의해 주십시오.

왜 구아바일까요?

주요 매력은 대부분의 경우 Guava 공장 방법을 사용하여 유형을 추정할 수 있기 때문에 형식 안전을 위한 제네릭으로 인한 혼란을 줄이는 것일 수 있다.그러나 Java 7이 새로운 다이아몬드 연산자와 함께 도착한 이후 이 주장은 설득력을 잃었습니다.

그러나 이것이 유일한 이유는 아니다(Java 7이 아직 모든 곳에 있는 것은 아니다).속기 구문도 매우 편리하고 메서드 이니셜라이저는 위에서 보듯이 보다 표현력 있는 코드를 쓸 수 있다.현재 Java Collections에서 2가 걸리는 작업을 1개의 Guava 호출로 수행합니다.

---

할 수 없는 경우...

불변 리스트의 경우

로 둘러싸인 JDK 의 클래스와 그 공장 출하시 방법을 사용합니다.

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

은 " " " 입니다.asList()는 입니다.ListArrayList실장하고 있지 않습니다. java.util.ArrayList 타입은 이너 타입으로, 타입은 이너 타입을 것입니다ArrayList그러나 실제로는 전달된 어레이를 직접 참조하여 "쓰기"하도록 합니다(수정 내용은 어레이에 반영됩니다).

은 금지되어 .List의 메서드.AbstractList및), ( 또는 삭제는 지원되지 않습니다.)로 수 .set()요소를 덮어씁니다. 이 는 완전히하는 것은 , 에의 콜도 입니다.asList()Collections.unmodifiableList().

변경 가능한 리스트가 필요한 경우는, 다음의 순서를 참조해 주세요.

가변 리스트의 경우

같으나 와 an with with with with with with with with same same same same same same same same same same same same same same same same same same.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));

5의 경우 Java 5의 경우Arrays.asList()는 varargs 파라미터를 사용하기 때문에 배열을 명시적으로 작성할 필요가 없습니다.

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

「 」가 되어 것을 확인합니다.myArray입니다.T을 컴파일러 List<Integer>로 늘어선 의 from an an int

다른 방법(본질적으로는 동일하지만)new ArrayList(Arrays.asList(array))다음 중 하나:

Collections.addAll(arraylist, array);

자바 9

Java 9에서는 스태틱팩토리 메서드를 사용하여List대그: : the like 。예를 들어 다음과 같습니다.

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를 위한 몇 가지 편리한 팩토리 메서드를 제공합니다.이러한 불변의 스태틱팩토리 방식은 Java 9 이후의 , 및 인터페이스에 포함되어 있습니다.

Array 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의 JDK의 실장은 빠르다.Arrays.asList(a[])아주 잘 익었어요.Arrays(어레이 리스트)를 선택합니다.[ Array List ](어레이 리스트)에서는 오브젝트[] 데이터가 어레이를 직접 가리킵니다.

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

또는 @glgl에서 설명한 바와 같이 를 사용하여 다른 독립된 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); 

Java 8 이후로는 다음과 같이 쉽게 변환할 수 있습니다.

import java.util.List;    
import static java.util.stream.Collectors.toList;

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

다른 방법을 사용하여 변환할 수 있습니다.

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

어레이를 작성하는 일반적인 최신 방법은 관찰 가능한 Arrays입니다.

[OvservableList] : 청취자가 변경이 발생했을 때 추적할 수 있는 목록입니다.

Java SE의 경우

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

Oracle Docs에 따르면

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

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)되며, 별별개 as a a a a a a a a a a a a a a a a a a a a로 수.var-args.

2. 이 질문에는 다른 답이 있을 수 있습니다.
   「」의 .java.util.Collections.addAll()을 사용하다

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

   따라서 이 코드를 사용하는 것도 편리합니다.

   Collections.addAll(arraylist, array);
   

배열이 원시 유형인 경우 지정된 답변이 작동하지 않습니다.그러나 Java 8부터는 다음을 사용할 수 있습니다.

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

다른 간단한 방법은 각 루프를 사용하여 어레이의 모든 요소를 새 ArrayList에 추가하는 것입니다.

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

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

이 질문에 대한 완벽한 답변이 많이 있지만, 저는 제 의견을 덧붙이겠습니다.

를 들어, '우리'가 있다고 .Element[] array = { new Element(1), new Element(2), new Element(3) };

새로운 Array List는 다음과 같은 방법으로 작성할 수 있습니다.

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

또한 Array List의 모든 작업을 매우 잘 지원합니다.

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 솔루션(대형 세트 중 답을 놓쳤을 수 있습니다). 그렇다면 죄송합니다.)그러면 (목록이 아닌) 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);
    }
}

★★★★★★★★★★★★。
하세요 ★★★
공통의

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

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

합니다.ArrayListCollection을 addAll()한 목록에서 다른 목록으로 콘텐츠를 복사하기 위한 방법.

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

요소 배열을 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]);
}

지정된 객체 배열:

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

어레이를 목록으로 변환:

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

어레이를 Array List로 변환

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

어레이를 Linked List로 변환

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

인쇄 목록:

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

산출량

1

2

3

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

여기에서는 두 가지 사용 사례에 대한 간단한 예를 제시하겠습니다.

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

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

• [Mutable collection creation] : : 생성 후 생성된 컬렉션 개체를 수정할 수 있는 경우.

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

Java 8의 Arrays 클래스는 원시 배열과 객체 배열을 모두 수용하는 오버로드 버전을 가진 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));

언급URL : https://stackoverflow.com/questions/157944/create-arraylist-from-array