한 줄로 ArrayList 초기화


2755

테스트 목적으로 옵션 목록을 만들고 싶었습니다. 처음에 나는 이것을했다 :

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

그런 다음 코드를 다음과 같이 리팩터링했습니다.

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

더 좋은 방법이 있습니까?


34
이것이 단위 테스트를 목적으로하는 경우 그루비를 사용해보십시오. Java 코드를 테스트하는 동안 테스트 코드를 작성하고 다음을 사용할 수 있습니다.ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]
ripper234

3
Java SE 7에서는 매개 변수화 된 생성자의 유형 매개 변수를 빈 유형의 매개 변수 유형 (<>)으로 대체 할 수 있습니다. Map <String, List <String >> myMap = new HashMap <> ();
Rose


2
더블 브레이싱 초기화 사용 :)
Mohammadreza Khatami

8
Stream.of ( "val1", "val2"). collect (Collectors.toList ()); // Java8 솔루션 인 ArrayList를 만듭니다.
torina

답변:


2025

실제로, 아마도 초기화하는 가장 좋은 ArrayList방법은 여러분이 작성한 방법 일 것입니다. 왜냐하면 List어떤 식 으로든 새로운 것을 만들 필요가 없기 때문입니다 .

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

잡는 것은 그 list인스턴스 를 참조하기 위해 약간의 타이핑이 필요하다는 것 입니다.

인스턴스 이니셜 라이저 ( "중괄호 초기화"라고도 함)를 사용하여 익명의 내부 클래스를 만드는 것과 같은 대안이 있습니다.

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

그러나, 당신이 끝내는 ArrayList것은 인스턴스 이니셜 라이저 가있는 서브 클래스이며 , 그 클래스는 하나의 객체를 만들기 위해 만들어 지기 때문에 그 방법을 좋아하지 않습니다 .

좋은 점은 Project Coin 에 대한 Collection Literals 제안 이 수락 된 경우였습니다 (Java 7에서 도입 될 예정이지만 Java 8에도 포함되지는 않습니다).

List<String> list = ["A", "B", "C"];

불행히도 여기 List보다는 불변을 초기화 할 것이므로 여기에서는 도움이되지 않으며 ArrayList, 더 이상 사용할 수 없다면 아직 사용할 수 없습니다.


172
이중 괄호 초기화, 장단점에 대한 자세한 내용은 stackoverflow.com/questions/924285 를 참조하십시오 .
Eddie

6
@ 에디 : 링크를 잘 부르십시오-이중 괄호 초기화에 관한 한 문장으로는 충분하지 않습니다.
coobird

2
Auto boxing List <Double> list = [1.0, 2.0, 3.0]에 의존하지 않는 경우에만 작동합니다. 실패합니다.
Richard B

1
더블리스트 초기화에 세미콜론이 없습니다
Don Larynx

6
이 답변이 가장 많이지지되고 언급 된 프로젝트 코인이므로 List.of (...) 구문과 함께 제공되는 java 9를 호출해야한다고 생각합니다. docs.oracle.com/javase/9/docs/api/java/util/ List.html # of-E ...-
Asaf

2155

그냥 선언하면 List- 더 간단 합니다-ArrayList 여야합니까?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

또는 하나의 요소 만있는 경우 :

List<String> places = Collections.singletonList("Buenos Aires");

이것은 그 의미 places한다 불변 (그것이 원인이됩니다 변경하려고 UnsupportedOperationException예외가 슬로우).

구체적으로 변경 가능한 목록을 만들려면 변경할 ArrayListArrayList없는 목록에서 만들 수 있습니다 .

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

18
@Marcase : ArrayList 대신 List를 사용하도록 클래스를 변경할 수 없습니까?
Lawrence Dol 2016 년

74
내 대답에 따라에 맞는 메서드를 사용하지 않으면 ArrayList선언을로 변경하는 것이 더 좋습니다 List. 구현이 아닌 인터페이스를 지정하십시오.
Christoffer Hammarström

9
@Christoffer Hammarström : 그는에 선언을 변경하는 경우 목록 및 사용 목록을 <문자열> 장소 = Arrays.asList (...); 그는 places.add ( "blabla")
maks

57
그냥 명확하게하기 위해, asList(...)고정 된 크기를 반환 List돌연변이 같은 작업에 불면 removeclear상황 List지원에 대한 계약 주장. 로 선언을 남겨 두어도 OperationNotSupported 예외를 발생시키지 않는 객체를 얻으려면 List반드시 사용해야 List l = new ArrayList(asList(...))합니다. Liskov 대체 원리 누구?
Splash

5
@Splash : removeclear의 선택적 작업 List이므로 asList(...)계약을 따릅니다. OP가 나중에 더 많은 요소를 추가해야한다고 말하는 곳은 없지만 예제는 List세 가지 요소로 초기화 해야하는 것입니다.
Christoffer Hammarström

872

간단한 대답

에서 자바 9 이상, 이후에 List.of()추가되었습니다

List<String> strings = List.of("foo", "bar", "baz");

함께 자바 10 이상 또는,이은으로 단축 할 수 있습니다 var키워드.

var strings = List.of("foo", "bar", "baz");

이것은 당신에게 불변 을 줄 List것이므로 변경할 수 없습니다.
당신이 그것을 미리 채우는 대부분의 경우에 당신이 원하는 것입니다.


Java 8 이하 :

List<String> strings = Arrays.asList("foo", "bar", "baz");

이렇게하면 List배열 이 지원되므로 길이를 변경할 수 없습니다.
그러나 당신은 호출 할 수 List.set있으므로 여전히 변경 가능 합니다.


Arrays.asList정적 가져 오기로 더 짧게 만들 수 있습니다 .

List<String> strings = asList("foo", "bar", "baz");

정적 가져 오기 :

import static java.util.Arrays.asList;  

최신 IDE가 자동으로 제안하고 자동으로 수행합니다.
예를 들어 IntelliJ IDEA에서을 누르고을 Alt+Enter선택 Static import method...합니다.


그러나 혼동을 일으키기 때문에 List.of방법을 단축하는 것은 좋지 않습니다 of.
List.of이미 충분히 짧고 잘 읽습니다.


Streams 사용

왜 그래야 List합니까?
Java 8 이상 Stream에서는 더 유연한 것을 사용할 수 있습니다 .

Stream<String> strings = Stream.of("foo", "bar", "baz");

Streams 를 연결할 수 있습니다 .

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

또는 a에서 a Stream로 이동할 수 있습니다 List.

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

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

그러나 가급적이면로 Stream수집하지 않고 사용하십시오 List.


당신이 경우 정말 특별히 필요java.util.ArrayList

(당신은 아마하지 않습니다.)
인용하자면 JEP 269 (강조 광산) :

작은 설정 값을 미리 정의 된 집합으로 변경 가능한 콜렉션 인스턴스를 초기화 사용 사례는. 일반적으로 사전 정의 된 값을 변경할 수없는 콜렉션에두고 복사 생성자를 통해 변경 가능한 콜렉션을 초기화하는 것이 좋습니다.


당신이 원하는 경우 모두 미리 채울 ArrayList (왜?) 이후에 그것을 사용을 추가

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

또는 Java 8 이하에서 :

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

또는 사용 Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

그러나 다시 Stream로 수집하는 대신 직접 사용하는 것이 좋습니다 List.


구현이 아닌 인터페이스에 대한 프로그램

ArrayList코드에서 목록을로 선언했다고 말 했지만에 ArrayList없는 일부 멤버를 사용하는 경우에만 목록을 작성해야합니다 List.

당신이하지 않을 가능성이 가장 높습니다.

일반적으로 당신은 당신이 (예를 들어, 사용하려고하는 가장 일반적인 인터페이스 변수를 선언해야한다 Iterable, Collection또는 List), 및 특정의 구현을 초기화 (예를 들어 ArrayList, LinkedList또는 Arrays.asList()).

그렇지 않으면 코드를 특정 유형으로 제한하므로 원하는 때 변경하기가 더 어려워집니다.

예를 들어, ArrayList에 a를 전달하는 경우 void method(...):

// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) { 
    for (String s : strings) { ... } 
}

// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
    if (!strings.isEmpty()) { strings.stream()... }
}

// List if you also need .get(index):
void method(List<String> strings) {
    strings.get(...)
}

// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
    ??? // You don't want to limit yourself to just ArrayList
}

또 다른 예 InputStream는 보통 a FileInputStream또는 a 이지만 변수를 항상 선언하는 것입니다. BufferedInputStream언젠가 당신이나 다른 누군가가 다른 종류의를 사용하기를 원하기 때문입니다 InputStream.


3
@ jollyroger : Arrays.asList정적 메소드입니다. docs.oracle.com/javase/1.5.0/docs/guide/language/…
Christoffer Hammarström

2
@ ChristofferHammarström이 경우, 저의 초보자 마음은 정적 가져 오기가 전역 변수 및 이러한 사용과 관련된 위험과 매우 유사하다는 것을 말해줍니다. 이 가정이 맞습니까? 위의 비슷한 대답이 더 많은 투표를받는 이유입니까?
jollyroger

2
위의 대답은 1 년 전에 이루어 졌다고 생각합니다. 그리고 전역 변수의 문제는 변수가 변경 가능하다는 것입니다. 정적 가져 오기와는 아무런 관련이 없습니다.
Christoffer Hammarström

2
정적 임포트를 원하지 않으면 정적 asList 메소드의 전체 경로를 정의 할 수도 있습니다. List <String> strings = java.util.Arrays.asList ( "", "");
Geert Weening

2
또는 import java.util.Arrays를 사용할 수 있습니다. and Arrays.asList ( "", ""); 정적 가져 오기를 사용할 필요가 없습니다. 전체 경로를 사용할 필요는 없습니다. 정적 메소드는 가져 오기에 신경 쓰지 않습니다. 인스턴스를 사용하여 찾을 경우 짜증이납니다.
candied_orange

111

간단한 크기 목록 1이 필요한 경우 :

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

여러 객체의 목록이 필요한 경우 :

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

57

구아바 를 사용하면 다음과 같이 작성할 수 있습니다.

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

구아바에는 또 다른 유용한 정적 생성자가 있습니다. 여기에서 그들에 대해 읽을 수 있습니다 .


1
다음과 java.util.Arrays같은 방법으로이 작업을 수행 할 수 있다고 확신합니다 .List<String> names = Arrays.asList("Beckah", "Sam", "Michael");
beckah

2
@beckah 메소드 Arrays.asLists는 List 유형의 객체를 생성하지만 질문은 ArrayList 생성에 관한 것입니다.
Paweł Adamski


34

컬렉션 리터럴은 Java 8로 만들지 않았지만 Stream API를 사용하여 하나의 긴 줄로 목록을 초기화 할 수 있습니다.

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

당신은 당신이 있는지 확인해야하는 경우 List입니다 ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

34

JEP 269 : Convenience Factory Methods for Collections 에서 제안한 바와 같이, 이제는-를 사용하여 콜렉션 리터럴을 사용하여 달성 할 수 있습니다.

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

유사한 접근 방식에 적용되는 것 Map뿐만 아니라 -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

이는 @coobird가 명시한 Collection Literals 제안 과 유사합니다 . JEP에서 더 명확히-


대안

언어 변경이 여러 번 고려되어 거부되었습니다.

프로젝트 코인 제안, 2009 년 3 월 29 일

프로젝트 코인 제안, 2009 년 3 월 30 일

2014 년 1 월 -3 월, lambda-dev에 대한 JEP 186 토론

언어 제안은이 메시지에 요약 된대로 라이브러리 기반 제안보다 우선적으로 제정되었습니다 .

관련 : Java 9에서 콜렉션에 대해 오버로드 된 편의 팩토리 메소드의 요점은 무엇입니까?


31
import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");

4
나는 그것을하기 위해 새로운 의존성을 추가하고 싶지 않습니다.
Macarse

6
정적 가져 오기와 함께 Collections.unmodifiableList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"))되는 것과 동일 unmodifiableList(asList("Buenos Aires", "Córdoba", "La Plata"))합니다. 이를 위해 Google 컬렉션이 필요하지 않습니다.
Christoffer Hammarström

9
아니요, 동일하지 않습니다. ImmutableList는 unmodifiableList가 일반 List로 가장 할 때 결과 유형에 불변성을 문서화하고 있습니다.
David Pierre

2
Google 컬렉션은 변경 불가능한 것 대신 변경 가능한 배열 목록도 제공합니다. List <String> = Lists.newArrayList ( "Buenos Aires", "Córdoba", "La Plata");
L. Holanda 21'40에

3
ImmutableList을 취하는 다른 메소드 로 전달 List하면 어쨌든 해당 문서를 잃어 버렸습니다.
Christoffer Hammarström

23

팩토리 메소드를 작성할 수 있습니다.

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

그러나 첫 번째 리팩토링보다 낫지는 않습니다.

유연성을 높이려면 다음과 같은 것이 일반적 일 수 있습니다.

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

1
원래 게시물을 다시 살펴보면 7 이 아닌 한 줄로 배열 초기화를 요구하고 있습니다.
L. Holanda

7
@ LeoHolanda : 모든 작은 것들에 대한 팩토리 메소드를 만드는 것은 너무 많습니다. 그러나 따라 , 그 방법을 사용하는 것입니다 횟수에 상황에, 그것을 생성하는 것이 바람직 할 수 있습니다. 추가 추상화 계층 을 만드는 것은 디자이너 의 의도 를 파악하는 보다 의미있는 방법을 만들어 복잡성 을 제거 하기 위한 것 입니다.
Jordão

16

Java 9에서는 ArrayList한 줄로 쉽게 초기화 할 수 있습니다 .

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

또는

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Java 9의이 새로운 접근 방식은 이전 방법에 비해 많은 장점이 있습니다.

  1. 공간 효율
  2. 불변성
  3. 스레드 안전

자세한 내용은이 게시물을 참조하십시오-> List.of와 Arrays.asList의 차이점은 무엇입니까?


8

가장 간단한 방법은 다음과 같습니다.

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

8

아래 코드를 다음과 같이 사용하십시오.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

2
@bsd이 메소드를 사용하여 메소드를 입력하기 전에 목록을 선언 할 수 있습니다. 따라서 클래스 변수를 정의 할 때 메소드를 호출하지 않고도 컨텐츠를 목록에 추가 할 수 있습니다.
melwil

2
이중 괄호 초기화는 가능한 멀리 피해야합니다. 참조 : stackoverflow.com/a/924326/760393
Raúl

8

Eclipse Collections 를 사용 하면 다음을 작성할 수 있습니다.

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

유형과 변경 가능 여부 또는 불변 여부에 대해 더 구체적으로 지정할 수 있습니다.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

세트와 가방에서도 동일한 작업을 수행 할 수 있습니다.

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

참고 : 저는 Eclipse Collections의 커미터입니다.


7

다른 방법은 다음과 같습니다.

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

7

(댓글이지만 너무 길어서 새 답글이어야 함). 다른 사람들이 언급 했듯이이 Arrays.asList방법은 고정 크기이지만 그것이 유일한 문제는 아닙니다. 또한 상속을 잘 처리하지 못합니다. 예를 들어 다음이 있다고 가정합니다.

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

B 타입의 객체를 객체에 추가 할 수 있더라도 ( List<B>Arrays.asList에 의해 반환되는) 컴파일러 의 하위 클래스가 아니기 때문에 위의 컴파일러 오류가 발생 합니다. 이 문제를 해결하려면 다음과 같은 작업을 수행해야합니다.List<A>List<A>

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

이것은 아마도 이것을하는 가장 좋은 방법 일 것입니다. 무제한 목록이 필요하거나 상속을 사용해야하는 경우


6

아래 진술을 사용할 수 있습니다.

코드 스 니펫 :

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

컴팩트 한 솔루션을 갖도록 첫 번째 표현식을 인라인 할 수 있습니다.letters = Arrays.asList(new String[]{"A", "B", "C"});
Pavel Repin

5

톰이 말한 것처럼 :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

그러나 ArrayList를 원한다고 불평했기 때문에 먼저 ArrayList가 List의 하위 클래스이며 다음 행을 추가 할 수 있다는 것을 알아야합니다.

ArrayList<String> myPlaces = new ArrayList(places);

그러나 그것은 '성능'에 대해 불평하게 할 수 있습니다.

이 경우 나에게 이해가되지 않습니다. 왜 목록이 미리 정의되어 있기 때문에 (초기화시 크기가 알려져 있기 때문에) 배열로 정의되지 않았습니다. 그리고 그것이 당신을위한 옵션이라면 :

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

약간의 성능 차이를 신경 쓰지 않으면 배열을 ArrayList에 매우 간단하게 복사 할 수도 있습니다.

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

좋습니다.하지만 나중에는 장소 이름보다 조금 더 많은 것이 필요하며 국가 코드도 필요합니다. 이 목록이 여전히 런타임 동안 변경되지 않는 사전 정의 된 목록이라고 가정하면 나중에 목록을 변경 enum해야 할 경우 다시 컴파일해야하는 세트 를 사용하는 것이 적합합니다 .

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

될 것입니다 :

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

열거 values형에는 선언 된 순서대로 열거 형의 모든 값을 포함하는 배열을 반환하는 정적 메소드가 있습니다.

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

이 경우 ArrayList가 필요하지 않은 것 같습니다.

PS Randyaa 는 정적 유틸리티 메소드 Collections.addAll을 사용하여 또 다른 좋은 방법을 시연했습니다 .


5

Java 9에는 변경 불가능한 목록 을 작성하는 다음 방법이 있습니다 .

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

필요한 경우 변경 가능한 목록을 쉽게 만들 수 있습니다.

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

비슷한 방법을 사용할 수 있습니다 SetMap.


1
명시 적으로 "불변 목록"이라고 말한 다음 언제 사용해야하는지 명확히하기 때문에 변경 가능한 목록의 또 다른 예를 보여주었습니다.
cherit


4

예, Arrays의 도움으로 한 줄에 배열 목록을 초기화 할 수 있습니다.

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");

4

CactoosStickyList 에서 사용할 수 있습니다 :

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

3

이 코드 라인을 사용해보십시오 :

Collections.singletonList(provider)

1
답변에 대한 간단한 설명을 추가하십시오.
Morales Batovski

2

Java에서는 할 수 없습니다

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

지적했듯이 이중 중괄호 초기화를 수행해야합니다.

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

그러나 이것은 주석을 추가 @SuppressWarnings("serial")하거나 성가신 직렬 UUID를 생성 하도록 강요 할 수 있습니다 . 또한 대부분의 코드 포맷터는이를 여러 명령문 / 라인으로 랩핑 해제합니다.

또는 당신은 할 수 있습니다

List<String> places = Arrays.asList(new String[] {"x", "y" });

그러나 당신은 할 수 있습니다 @SuppressWarnings("unchecked").

또한 javadoc에 따르면 다음을 수행 할 수 있어야합니다.

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

그러나 JDK 1.6으로 컴파일 할 수는 없습니다.


5
잘못된! 당신 첫 번째 줄을 있습니다 . 그리고 그것은 정답입니다 btw
Bohemian

1
Collections.singletonList(messageBody)

당신은 하나의 항목 의 목록이 필요합니다 !

컬렉션java.util 패키지 에서 가져온 것 입니다.


1

가장 좋은 방법은 :

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

원하는만큼의 요소를 가질 수있는 함수를 만들고 한 줄에 추가하기 위해 호출하십시오.


1
모든 문제를 겪는다면 plain 대신 템플릿 방법으로 만들 수도 있습니다 Object.
Robert

1

다음은 AbacusUtil의 코드입니다 .

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

선언 : 저는 AbacusUtil의 개발자입니다.


0

나에게 Arrays.asList ()는 가장 편리하고 편리합니다. 나는 항상 그런 식으로 초기화하고 싶습니다. Java Collections 초보자라면 ArrayList 초기화 를 참조하십시오.


add()메소드를 사용 하여 한 줄에 새 ArrayList를 만드는 것보다 Arrays.asList ()가 더 나은 이유는 무엇 입니까?
IgorGanapolsky

0

이것을하는 간단한 유틸리티 함수를 만들어 보시겠습니까?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

" ll"는 "문자 목록"을 나타냅니다.

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");

0

흥미롭게도 다른 오버로드 된 방법을 가진 하나의 라이너 Stream::collect 가 나열되지 않습니다.

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );

-1

실제로 한 줄로 할 수 있습니다.

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})

3
이것이 질문에 무엇이 추가되는지 물어봐도 될까요? 이 답변은 이미 다른 답변으로 여러 번 다루고 있습니다.
Mysticial 2016 년

이것은 요약 목록을 생성하기 때문에 실제로는 정말 나쁜 해결책입니다. 컨테이너에 더 이상 아무것도 추가 할 수 없습니다.
Atais
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.