Java에서 새 목록을 만드는 방법

우리는 다음 Set과 같이 만듭니다 .

Set myset = new HashSet()

ListJava로 어떻게 작성 합니까?

List myList = new ArrayList();

또는 제네릭 사용 ( Java 7 이상)

List<MyType> myList = new ArrayList<>();

또는 제네릭 (오래된 Java 버전)

List<MyType> myList = new ArrayList<MyType>();

또한 목록이있는 목록을 만들려면 크기가 고정되어 있지만 :

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

요약하고 무언가를 추가하겠습니다.

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

구아바

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

불변 목록

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

빈 불변 목록

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

문자 목록

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

정수 목록

Ints.asList(1,2,3);                                             // Guava

자바 8에서

비어 있지 않은 고정 크기 목록을 작성하려면 (add, remove 등의 작업은 지원되지 않음) :

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

비어 있지 않은 변경 가능 목록을 작성하려면 다음을 수행하십시오.

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

자바 9

새로운 List.of(...)정적 팩토리 메소드 사용 :

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

자바 10

은 Using 지역 변수 유형 추론을 :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

모범 사례를 따르십시오.

원시 유형을 사용하지 마십시오

Java 5부터 generics는 언어의 일부 였으므로 다음을 사용해야합니다.

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

인터페이스 프로그램

예를 들어, List인터페이스에 프로그램하십시오 .

List<Double> list = new ArrayList<>();

대신에:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!

먼저 이것을 읽은 다음 이것 과 이것을 읽으십시오 . 10 중 9 번이 두 구현 중 하나를 사용합니다.

실제로, Sun의 Collections to Collections 프레임 워크를 읽으십시오 .

//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());

Java 7부터 일반 인스턴스 작성에 대한 유형 유추가 있으므로 할당의 오른쪽에 일반 매개 변수를 복제 할 필요가 없습니다.

List<String> list = new ArrayList<>();

고정 크기 목록은 다음과 같이 정의 할 수 있습니다.

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

불변 목록의 경우 Guava 라이브러리를 사용할 수 있습니다 .

List<String> list = ImmutableList.of("foo", "bar");

List 는 Set 과 같은 인터페이스 일뿐 입니다.

HashSet은 성능 추가 / 조회 / 제거와 관련하여 특정 속성이있는 Set의 구현처럼 ArrayList는 List의 기본 구현입니다.

해당 인터페이스에 대한 설명서를 보면 "알려진 모든 구현 클래스"를 찾을 수 있으며 어느 것이 더 적합한 지 결정할 수 있습니다.

ArrayList 일 가능성이 있습니다.

List인터페이스처럼 Set및 보유 ArrayList와 LinkedList같은 범용 구현 .

다음과 같이 List를 만들 수 있습니다.

 List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>(); 

다음과 같이 고정 크기 목록을 만들 수도 있습니다.

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

우리는 거의 항상 구현에 ArrayList반대하여 사용 LinkedList합니다.

1. LinkedList 객체에 많은 공간을 사용하고 많은 요소가있을 때 성능이 떨어집니다.
2. 의 인덱싱 된 작업은의 LinkedListO (1)에 비해 O (n) 시간이 필요합니다 ArrayList.
3. 자세한 내용은 이 링크 를 확인 하십시오.

Arrays.asList위에서 만든 목록은 구조적으로 수정할 수 없지만 해당 요소는 여전히 수정할 수 있습니다.

자바 8

당으로 문서 , 방법은 Collections.unmodifiableList지정된리스트의 변경 불가능한 뷰를 돌려줍니다. 우리는 그것을 얻을 수 있습니다 :

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

자바 9

우리가 Java 9 를 사용하는 경우 :

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

자바 10

경우에 우리는 그 다음 방법은 자바 (10)에있다 Collectors.unmodifiableList이 확인 9. 자바에 도입 진정 불가능한리스트의 인스턴스를 반환 대답 의 차이에 대한 자세한 정보를 원하시면 Collections.unmodifiableList 대 Collectors.unmodifiableList에서 자바 (10) .

때때로 새로운 ArrayList 대신에 아주 드물게 새로운 LinkedList를 원할 수도 있습니다. ArrayList로 시작하고 성능 문제와 목록에 문제가 있음을 나타내는 증거가 있고 그 목록에 추가 및 삭제하는 경우가 많지만 LinkedList로 전환하여 상황이 개선되는지 확인하십시오. 그러나 기본적으로 ArrayList를 고수하면 모두 괜찮습니다.

List list = new ArrayList();

또는 제네릭

List<String> list = new ArrayList<String>();

물론 문자열을 Integer와 같은 변수 유형으로 바꿀 수도 있습니다.

한 가지 예 :

List somelist = new ArrayList();

List 에 대한 javadoc을 보고 ListJava API에 포함 된 인터페이스 의 알려진 모든 구현 클래스를 찾을 수 있습니다.

Google 컬렉션을 사용 하면 Lists 클래스 에서 다음 메소드를 사용할 수 있습니다.

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

에서 varargs 초기화 및 초기화에 대한 과부하가 있습니다 Iterable<T>.

이 메소드의 장점은 생성자와 마찬가지로 일반 매개 변수를 명시 적으로 지정할 필요가 없다는 것입니다. 컴파일러는 변수 유형에서이를 유추합니다.

List<Object> nameOfList = new ArrayList<Object>();

당신은 가져올 필요 List하고 ArrayList.

Java 8과 동일한 작업을 수행하는 더 많은 옵션이 나쁘지 않고 다르지 않으며 다른 목록으로 추가 작업을 수행하려는 경우 Streams 는 더 많은 대안 (필터, 맵, 축소 등)을 제공합니다.

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));

Java 9에서는 다음을 수행하여 변경 불가능한 것을 작성할 수 있습니다 List.

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);

옵션으로 이중 괄호 초기화를 사용할 수 있습니다.

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

집합과 목록을 만드는 방법에는 여러 가지가 있습니다. HashSet과 ArrayList는 두 가지 예일뿐입니다. 요즘 컬렉션에 제네릭을 사용하는 것도 일반적입니다. 나는 그들이 무엇인지 살펴볼 것을 제안합니다

이것은 자바의 내장 컬렉션에 대한 좋은 소개입니다. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

아래 제안 된대로 제네릭을 사용하는 것이 좋습니다.

List<String> arrList = new ArrayList<String>();

arrList.add("one");

LinkedList를 사용하는 경우.

List<String> lnkList = new LinkedList<String>();

Eclipse 콜렉션 을 사용하여 다음과 같이 목록을 작성할 수 있습니다.

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

불변 목록을 원할 경우 :

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

기본 목록을 사용하여 자동 복싱을 피할 수 있습니다. int 목록을 작성하는 방법은 다음과 같습니다.

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

8 가지 프리미티브 모두에 ​​대한 변형이 있습니다.

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

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

다음은 목록을 생성 할 수있는 몇 가지 방법입니다.

• 이렇게하면 고정 크기의 목록이 생성되고 요소를 추가 / 제거 할 수 없으며 java.lang.UnsupportedOperationException그렇게하려고 하면를 던집니다 .

  List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});

• 다음 버전은 여러 요소를 추가 / 제거 할 수있는 간단한 목록입니다.

  List<String> list = new ArrayList<>();

• 이것은 LinkedList자바에서 를 만드는 방법 입니다. 목록에서 요소를 자주 삽입 / 삭제 해야하는 경우 LinkedList대신에 사용해야 합니다ArrayList

  List<String> linkedList = new LinkedList<>();

이 시도:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

또는:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

단일 엔티티로 직렬화 가능하고 변경 불가능한 목록이 필요한 경우 다음을 사용할 수 있습니다.

List<String> singList = Collections.singletonList("stackoverlow");

자바에서 배열 목록의 선언은

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

java에서 배열 목록을 만들고 초기화 할 수있는 방법은 여러 가지가 있습니다.

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();