Cách tạo một Danh sách mới trong Java

Chúng tôi tạo ra Setnhư:

Set myset = new HashSet()

Làm thế nào để chúng ta tạo một ListJava?

List myList = new ArrayList();

hoặc với generic ( Java 7 trở lên)

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

hoặc với generic (phiên bản java cũ)

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

Ngoài ra, nếu bạn muốn tạo một danh sách có những thứ trong đó (mặc dù nó sẽ có kích thước cố định):

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

Hãy để tôi tóm tắt và thêm một cái gì đó:

JDK

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

Trái ổi

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

Danh sách bất biến

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

Danh sách bất biến

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

Danh sách nhân vật

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

Danh sách các số nguyên

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

Trong Java 8

Để tạo danh sách kích thước cố định không trống (các thao tác như thêm, xóa, v.v., không được hỗ trợ):

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

Để tạo một danh sách đột biến không trống:

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

Trong Java 9

Sử dụng một List.of(...)phương thức tĩnh nhà máy mới:

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

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

Trong Java 10

Sử dụng suy luận kiểu biến cục bộ :

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

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

var list3 = new ArrayList<String>();

Và làm theo các thực hành tốt nhất ...

Không sử dụng loại thô

Kể từ Java 5, generic đã là một phần của ngôn ngữ - bạn nên sử dụng chúng:

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

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

Chương trình giao diện

Ví dụ: chương trình tới Listgiao diện:

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

Thay vì:

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

Đầu tiên đọc cái này , rồi đọc cái này và cái này . 9 trong số 10 lần bạn sẽ sử dụng một trong hai triển khai đó.

Trên thực tế, chỉ cần đọc Hướng dẫn của Sun về khung Bộ sưu tập .

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

Vì Java 7, bạn có kiểu suy luận để tạo cá thể chung , do đó không cần phải sao chép các tham số chung ở phía bên phải của phép gán:

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

Một danh sách kích thước cố định có thể được định nghĩa là:

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

Đối với danh sách bất biến, bạn có thể sử dụng thư viện Guava :

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

Danh sách chỉ là một giao diện giống như Set .

Giống như Hashset là một triển khai của Tập hợp có các thuộc tính nhất định liên quan đến hiệu suất thêm / tra cứu / loại bỏ, ArrayList là triển khai thực hiện Danh sách.

Nếu bạn xem tài liệu về các giao diện tương ứng, bạn sẽ tìm thấy "Tất cả các lớp triển khai đã biết" và bạn có thể quyết định cái nào phù hợp hơn với nhu cầu của mình.

Rất có thể đó là ArrayList .

Listlà một giao diện như Setvà có ArrayListvà LinkedListnhư là thực hiện mục đích chung .

Chúng tôi có thể tạo Danh sách như:

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

Chúng tôi cũng có thể tạo một danh sách kích thước cố định như:

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

Chúng tôi hầu như luôn luôn sử dụng ArrayListtrái ngược với LinkedListthực hiện:

1. LinkedList sử dụng nhiều không gian cho các đối tượng và hoạt động kém khi chúng ta có nhiều yếu tố.
2. Bất kỳ hoạt động được lập chỉ mục nào trong LinkedListthời gian yêu cầu O (n) so với O (1) trong ArrayList.
3. Kiểm tra liên kết này để biết thêm thông tin.

Danh sách được tạo bởi Arrays.asListở trên không thể được sửa đổi về mặt cấu trúc nhưng các yếu tố của nó vẫn có thể được sửa đổi.

Java 8

Theo tài liệu , phương thức Collections.unmodifiableListtrả về một khung nhìn không thể thay đổi của danh sách đã chỉ định. Chúng ta có thể có được nó như sau:

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

Java 9

Trong trường hợp chúng tôi đang sử dụng Java 9 thì:

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

Java 10

Trong trường hợp chúng ta đang ở Java 10 thì phương thức Collectors.unmodifiableListsẽ trả về một thể hiện của danh sách thực sự không thể thay đổi được giới thiệu trong Java 9. Kiểm tra câu trả lời này để biết thêm thông tin về sự khác biệt Collections.unmodifiableList so với Collectors.unmodifiableListtrong Java 10 .

Đôi khi - nhưng chỉ rất hiếm khi - thay vì một ArrayList mới, bạn có thể muốn một LinkedList mới. Bắt đầu với ArrayList và nếu bạn gặp vấn đề về hiệu năng và bằng chứng cho thấy danh sách đó là vấn đề, và rất nhiều việc thêm và xóa vào danh sách đó - sau đó - không phải trước đó - hãy chuyển sang LinkedList và xem mọi thứ có cải thiện không. Nhưng trong chính, hãy gắn bó với ArrayList và tất cả sẽ ổn.

List list = new ArrayList();

Hoặc với thuốc generic

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

Tất nhiên, bạn có thể thay thế chuỗi bằng bất kỳ loại biến nào, chẳng hạn như Integer ,.

Một ví dụ:

List somelist = new ArrayList();

Bạn có thể xem javadoc cho Danh sách và tìm tất cả các lớp triển khai đã biết của Listgiao diện được bao gồm trong api java.

Sử dụng Bộ sưu tập của Google , bạn có thể sử dụng các phương thức sau trong lớp Danh sách

import com.google.common.collect.Lists;

// ...

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

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

Có quá tải cho khởi tạo varargs và khởi tạo từ một Iterable<T>.

Ưu điểm của các phương thức này là bạn không cần chỉ định rõ ràng tham số chung như bạn làm với hàm tạo - trình biên dịch sẽ suy ra nó từ loại biến.

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

Bạn cần nhập Listvà ArrayList.

Nhiều tùy chọn hơn để làm điều tương tự với Java 8, không tốt hơn, không tệ hơn, chỉ khác và nếu bạn muốn thực hiện thêm một số công việc với danh sách, Luồng sẽ cung cấp cho bạn nhiều lựa chọn thay thế (bộ lọc, bản đồ, giảm, v.v.)

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

Với Java 9, bạn có thể thực hiện các thao tác sau để tạo một bất biến List :

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

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

Như một tùy chọn, bạn có thể sử dụng khởi tạo cú đúp ở đây:

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

Có nhiều cách để tạo Tập hợp và Danh sách. Hashset và ArrayList chỉ là hai ví dụ. Nó cũng khá phổ biến để sử dụng thuốc generic với các bộ sưu tập ngày nay. Tôi đề nghị bạn nên xem chúng là gì

Đây là một giới thiệu tốt cho các bộ sưu tập dựng sẵn của java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

Tốt hơn bạn nên sử dụng thuốc generic như đề xuất dưới đây:

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

arrList.add("one");

Trong trường hợp bạn sử dụng LinkedList.

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

Sử dụng Bộ sưu tập Eclipse, bạn có thể tạo một Danh sách như thế này:

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

Nếu bạn muốn một danh sách bất biến:

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

Bạn có thể tránh tự động đấm bốc bằng cách sử dụng danh sách nguyên thủy. Đây là cách bạn tạo danh sách 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);

Có các biến thể cho tất cả 8 nguyên thủy.

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

Lưu ý: Tôi là người đi làm cho Bộ sưu tập Eclipse.

Sau đây là một số cách bạn có thể tạo danh sách.

• Điều này sẽ tạo ra một danh sách với kích thước cố định, việc thêm / xóa các yếu tố là không thể, nó sẽ ném java.lang.UnsupportedOperationExceptionnếu bạn cố gắng làm như vậy.

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

• Phiên bản sau đây là một danh sách đơn giản nơi bạn có thể thêm / xóa bất kỳ số lượng phần tử nào.

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

• Đây là cách tạo một LinkedListjava, Nếu bạn cần thường xuyên chèn / xóa các phần tử trong danh sách, bạn nên sử dụng LinkedListthay vìArrayList

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

Thử cái này:

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

Hoặc là:

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

Nếu bạn cần một danh sách tuần tự, bất biến với một thực thể duy nhất bạn có thể sử dụng:

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

Như khai báo danh sách mảng trong java giống như

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

Có rất nhiều cách bạn có thể tạo và khởi tạo danh sách mảng trong 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();