Tạo ArrayList từ mảng


3596

Tôi có một mảng được khởi tạo như:

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

Tôi muốn chuyển đổi mảng này thành một đối tượng của ArrayListlớp.

ArrayList<Element> arraylist = ???;

49
Trong Java9 -> Danh sách <String> list = List.of (ăn xin
MarekM

18
@MarekM Câu trả lời này là sai, vì điều này không trả về ArrayList. Poster yêu cầu cụ thể cho điều đó.
Dorian Gray

4
Tôi nghĩ rằng anh ta đã không khai thác bằng giao diện List, vì đó là cách tốt nhất. Nhưng nếu bạn muốn ở đây là - ArrayList mới <> (List.of (thì Hello Hello,, World World,, từ từ, Java, Java));
MarekM

10
Vấn đề không phải là về việc sử dụng giao diện, vấn đề là trong giải pháp của bạn, danh sách được trả về là không thể thay đổi. Đó có thể là vấn đề nhiều hơn và là lý do tại sao anh ta yêu cầu ArrayList
Dorian Gray

Câu trả lời:


4603
new ArrayList<>(Arrays.asList(array));

361
Vâng. Và trong trường hợp (phổ biến nhất) mà bạn chỉ muốn một danh sách, new ArrayListcuộc gọi cũng không cần thiết.
Calum

143
@Luron - chỉ cần sử dụngList<ClassName> list = Arrays.asList(array)
Bi-a

248
@Calum và @Pool - như được lưu ý dưới đây trong câu trả lời của Alex Miller, sử dụng Arrays.asList(array)mà không chuyển nó vào một ArrayListđối tượng mới sẽ sửa kích thước của danh sách. Một trong những lý do phổ biến hơn để sử dụng ArrayListlà có thể thay đổi kích thước của nó một cách linh hoạt và đề xuất của bạn sẽ ngăn chặn điều này.
Mã J Racer

130
Arrays.asList () là một hàm khủng khiếp và bạn không bao giờ nên sử dụng giá trị trả về của nó. Nó phá vỡ mẫu Danh sách, vì vậy luôn luôn sử dụng nó trong biểu mẫu được chỉ ra ở đây, ngay cả khi nó có vẻ dư thừa. Câu trả lời tốt.
Adam

83
@Adam Vui lòng nghiên cứu javadoc cho java.util.List. Hợp đồng cho phép thêm cho phép họ ném UnceptionedOperationException. docs.oracle.com/javase/7/docs/api/java/util/ khuyên Phải thừa nhận, từ góc độ hướng đối tượng, thật không hay khi nhiều lần bạn phải biết triển khai cụ thể để sử dụng một bộ sưu tập - điều này là một lựa chọn thiết kế thực dụng để giữ cho khung đơn giản.
lbalazscs

918

Được:

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

Câu trả lời đơn giản nhất là làm:

List<Element> list = Arrays.asList(array);

Điều này sẽ làm việc tốt. Nhưng một số hãy cẩn thận:

  1. Danh sách được trả về từ asList có kích thước cố định . Vì vậy, nếu bạn muốn có thể thêm hoặc xóa các thành phần khỏi danh sách được trả về trong mã của mình, bạn sẽ cần phải bọc nó mới ArrayList. Nếu không, bạn sẽ nhận được một UnsupportedOperationException.
  2. Danh sách được trả về từ asList()được hỗ trợ bởi mảng ban đầu. Nếu bạn sửa đổi mảng ban đầu, danh sách cũng sẽ được sửa đổi. Điều này có thể gây ngạc nhiên.

6
Độ phức tạp thời gian của cả hai hoạt động là gì? Tôi có nghĩa là có và không sử dụng xây dựng danh sách mảng rõ ràng.
chết tiệt

35
Arrays.asList () chỉ tạo một ArrayList bằng cách gói mảng hiện có để nó là O (1).
Alex Miller

27
Việc gói trong một ArrayList mới () sẽ khiến tất cả các thành phần của danh sách kích thước cố định được lặp lại và thêm vào ArrayList mới, do đó là O (n).
Alex Miller

8
việc triển khai Danh sách được trả về bởi asList () không triển khai một số phương thức của List (như add (), remove (), clear (), v.v ...) giải thích UnsupportedOperationException. chắc chắn là một cảnh báo ...
sethro

8
Khi câu hỏi yêu cầu "một đối tượng của lớp ArrayList", tôi nghĩ thật hợp lý khi giả định lớp mà nó đề cập đến là java.util.ArrayList. Arrays.asList thực sự trả về một java.util.Arrays.ArrayListcái không phải là một instanceoflớp khác. Vì vậy, một cảnh báo thứ ba là nếu bạn cố gắng sử dụng nó trong bối cảnh yêu cầu ở trên thì nó sẽ không hoạt động.
Dave L.

352

(chủ đề cũ, nhưng chỉ 2 xu như không đề cập đến ổi hoặc các lib khác và một số chi tiết khác)

Nếu bạn có thể, hãy sử dụng ổi

Thật đáng để chỉ ra cách ổi, giúp đơn giản hóa rất nhiều những kẻ lừa đảo này:

Sử dụng

Đối với một danh sách bất biến

Sử dụng ImmutableListlớp và các phương thức của nó of()copyOf()nhà máy (các phần tử không thể rỗng) :

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

Cho một danh sách có thể thay đổi

Sử dụng Listslớp và newArrayList()phương thức xuất xưởng của nó :

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

Cũng xin lưu ý các phương thức tương tự cho các cấu trúc dữ liệu khác trong các lớp khác, ví dụ như trong Sets.

Tại sao ổi?

Điểm thu hút chính có thể là giảm sự lộn xộn do thuốc generic cho an toàn loại, vì việc sử dụng các phương pháp của nhà máy ổi cho phép các loại được suy ra hầu hết thời gian. Tuy nhiên, đối số này giữ ít nước hơn kể từ khi Java 7 đến với toán tử kim cương mới.

Nhưng đó không phải là lý do duy nhất (và Java 7 chưa có ở mọi nơi): cú pháp tốc ký cũng rất tiện dụng và các trình khởi tạo phương thức, như đã thấy ở trên, cho phép viết mã biểu cảm hơn. Bạn thực hiện trong một cuộc gọi Guava, mất 2 với Bộ sưu tập Java hiện tại.


Nếu bạn không thể ...

Đối với một danh sách bất biến

Sử dụng Arrayslớp của JDK và asList()phương thức xuất xưởng của nó , được gói bằng Collections.unmodifiableList():

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

Lưu ý rằng loại trả về cho asList()Listsử dụng ArrayListtriển khai cụ thể , nhưng KHÔNG java.util.ArrayList . Đó là một loại bên trong, mô phỏng mộtArrayList nhưng thực sự trực tiếp tham chiếu mảng đã truyền và làm cho nó "ghi thông qua" (sửa đổi được phản ánh trong mảng).

Nó cấm sửa đổi thông qua một số Listphương thức của API bằng cách mở rộng một AbstractList(vì vậy, việc thêm hoặc xóa các phần tử không được hỗ trợ), tuy nhiên, nó cho phép các lệnh gọi set()để ghi đè các phần tử. Do đó, danh sách này không thực sự bất biến và asList()cần phải có một lời kêu gọi Collections.unmodifiableList().

Xem bước tiếp theo nếu bạn cần một danh sách có thể thay đổi.

Đối với một danh sách có thể thay đổi

Tương tự như trên, nhưng được bao bọc bằng một thực tế 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+

Đối với mục đích giáo dục: Cách thủ công của ol

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

27
+1 Nhưng lưu ý rằng Listtrả về bởi Arrays.asListcó thể thay đổi ở chỗ bạn vẫn có thể setthành phần - nó không thể thay đổi kích thước. Đối với danh sách bất biến mà không có ổi bạn có thể đề cập Collections.unmodifiableList.
Paul Bellora

1
@haylem Trong phần của bạn cho các mục đích giáo dục: Cách thủ công của ol tốt , arrayToListJava 1.5+ của bạn không chính xác. Bạn đang liệt kê danh sách Stringvà cố gắng truy xuất các chuỗi từ mảng đã cho, thay vì sử dụng loại tham số chung , T. Ngoài ra, câu trả lời hay và +1 là cách duy nhất bao gồm cả cách thủ công.
afsantos

Id 'đổi tên phần của bạn "Nếu bạn không thể ... / Đối với một danh sách không thay đổi" thành "Đối với một danh sách không thể thay đổi" vì nó có thể bị thay đổi bởi những thay đổi sau này đối với mảng được bọc. Vẫn còn O(1), nhưng để bất biến, bạn phải tạo một bản sao, ví dụ: bởi Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))).
maaartinus

232

Vì câu hỏi này khá cũ, điều làm tôi ngạc nhiên là chưa ai đề xuất hình thức đơn giản nhất:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

Kể từ Java 5, Arrays.asList()lấy tham số varargs và bạn không phải xây dựng mảng một cách rõ ràng.


7
Đặc biệt,List<String> a = Arrays.asList("first","second","third")
18446744073709551615

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

Hãy chắc chắn rằng đó myArraylà cùng loại với T. Chẳng hạn, bạn sẽ gặp lỗi trình biên dịch nếu bạn cố gắng tạo một List<Integer>mảng từ một mảng int.


103

Một cách khác (mặc dù về cơ bản tương đương với new ArrayList(Arrays.asList(array))giải pháp hiệu quả:

Collections.addAll(arraylist, array);

96

Java 9

Trong Java 9 , bạn có thể sử dụng List.ofphương thức nhà máy tĩnh để tạo ra một Listchữ. Một cái gì đó như sau:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Điều này sẽ trả về một danh sách bất biến chứa ba yếu tố. Nếu bạn muốn một danh sách có thể thay đổi , hãy chuyển danh sách đó cho hàm ArrayListtạo:

new ArrayList<>(List.of(// elements vararg))

JEP 269: Phương pháp nhà máy tiện lợi cho các bộ sưu tập

JEP 269 cung cấp một số phương thức nhà máy tiện lợi cho API Bộ sưu tập Java . Những phương pháp nhà máy tĩnh bất biến được xây dựng vào List, SetMapgiao diện trong Java 9 và sau đó.


List.of () sẽ không trả về một thể hiện của java.util.ArrayList, như được yêu cầu trong câu hỏi ban đầu. Do đó, chỉ có lựa chọn thứ hai là một câu trả lời hợp lệ.
tquadrat

84

Bạn có thể chỉ cần một Danh sách, không phải là một ArrayList. Trong trường hợp đó bạn chỉ có thể làm:

List<Element> arraylist = Arrays.asList(array);

8
Điều đó sẽ được hỗ trợ bởi mảng đầu vào ban đầu, đó là lý do tại sao bạn (có thể) muốn bọc nó trong một ArrayList mới.
Lập hóa đơn cho Thằn lằn

16
Hãy cẩn thận với giải pháp này. Nếu bạn nhìn, Mảng ISN'T không trả lại java.util.ArrayList thực sự. Nó trả về một lớp bên trong thực hiện các phương thức cần thiết, nhưng bạn không thể thay đổi các bộ nhớ trong danh sách. Nó chỉ đơn thuần là một trình bao bọc xung quanh một mảng.
Mikezx6r

1
Bạn có thể truyền mục Danh sách <Element> thành ArrayList <Element>
monksy

12
@ Mikezx6r: chỉnh sửa nhỏ : đó là danh sách kích thước cố định. Bạn có thể thay đổi các thành phần của danh sách ( setphương thức), bạn không thể thay đổi kích thước của danh sách (không phải addhoặc removecác thành phần)!
dùng85421

1
Vâng, với sự cảnh báo rằng nó phụ thuộc vào những gì bạn muốn làm với danh sách. Điều đáng chú ý là nếu OP chỉ đơn giản muốn lặp qua các phần tử, thì mảng đó hoàn toàn không phải chuyển đổi.
PaulM bồCbr

69

Một bản cập nhật khác, gần như kết thúc năm 2014, bạn cũng có thể làm điều đó với Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

Một vài ký tự sẽ được lưu, nếu đây có thể chỉ là một List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

8
Có lẽ tốt nhất là không phụ thuộc vào việc thực hiện, nhưng Collectors.toList()thực sự trả về một ArrayList.
bcsb1001

sử dụng Stream.of (...) không chính xác; Điều đó sẽ tạo ra một luồng một yếu tố. Sử dụng Arrays.stream thay thế
Patrick Parker

Tôi không nghĩ vậy, 2 tùy chọn là hợp lệ nhưng Arrays.stream hơi 'tốt hơn' vì bạn có thể tạo nó với kích thước cố định, sử dụng phương thức quá tải với 'start', 'end'. Xem thêm: stackoverflow.com/a/27888447/2619091
whyem

41

Nếu bạn dùng :

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

bạn có thể tạo và điền hai danh sách! Điền hai lần một danh sách lớn chính xác là những gì bạn không muốn làm bởi vì nó sẽ tạo ra một Object[]mảng khác mỗi khi dung lượng cần được mở rộng.

May mắn là việc thực hiện JDK rất nhanh và Arrays.asList(a[])được thực hiện rất tốt. Nó tạo ra một loại ArrayList có tên Arrays.ArrayList trong đó dữ liệu Object [] trỏ trực tiếp vào mảng.

// 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
    }
    ....
}

Mặt nguy hiểm là nếu bạn thay đổi mảng ban đầu, bạn thay đổi Danh sách!Bạn có chắc chắn muốn điều đó? Có thể có có thể không.

Nếu không, cách dễ hiểu nhất là làm điều này:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Hoặc như đã nói @glglgl, bạn có thể tạo một ArrayList độc lập khác với:

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

Tôi thích sử dụng Collections, Arrayshoặc ổi. Nhưng nếu nó không phù hợp, hoặc bạn không cảm thấy nó, thay vào đó chỉ cần viết một dòng không phù hợp khác.


1
Tôi không thấy sự khác biệt cơ bản giữa vòng lặp của bạn ở cuối câu trả lời và new ArrayList<T>(Arrays.asList(myArray));phần mà bạn không khuyến khích sử dụng. Cả hai đều làm khá giống nhau và có cùng độ phức tạp.
glglgl

Bộ sưu tập tạo một con trỏ ở đầu mảng. Vòng lặp của tôi tạo ra nhiều con trỏ: một cho mỗi thành viên mảng. Vì vậy, nếu mảng ban đầu thay đổi, các nhà thơ của tôi vẫn hướng đến các giá trị trước đây.
Nicolas Zozol

1
new ArrayList<T>(Arrays.asList(myArray));cũng vậy, nó sao chép asListvào một ArrayList...
glglgl

37

Trong Java 9bạn có thể sử dụng:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

Lưu ý rằng đây không phải là một ArrayList, vì nó đã được hỏi rõ ràng.
Dorian Gray

33

Theo câu hỏi, câu trả lời sử dụng java 1.7 là:

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

Tuy nhiên, tốt hơn hết là luôn sử dụng giao diện:

List<Element> arraylist = Arrays.<Element>asList(array);

30
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 


21

như tất cả đã nói điều này sẽ làm như vậy

 new ArrayList<>(Arrays.asList("1","2","3","4"));

và cách phổ biến mới nhất để tạo mảng là có thể quan sát được

Danh sách quan sát: Một danh sách cho phép người nghe theo dõi các thay đổi khi chúng xảy ra.

cho Java SE bạn có thể thử

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

đó là theo Oracle Docs

obsableArrayList () Tạo một danh sách có thể quan sát trống mới được hỗ trợ bởi một danh sách mảng. obsableArrayList (E ... items) Tạo một danh sách mảng có thể quan sát mới với các mục được thêm vào nó.

Cập nhật Java 9

cũng trong Java 9, nó hơi dễ một chút:

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

20

Vì Java 8 có một cách dễ dàng hơn để chuyển đổi:

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

18

Bạn cũng có thể làm điều đó với luồng trong Java 8.

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

3
Kể từ java 8 , Collectors.toList()sẽ trả về một ArrayList. Tuy nhiên, điều này có thể khác nhau trong các phiên bản tương lai trên java. Nếu bạn muốn một loại bộ sưu tập cụ thể thì hãy sử dụng Collectors.toCollection()thay vì nơi bạn có thể chỉ định loại bộ sưu tập chính xác mà bạn muốn tạo.
Raja Anbazhagan

14
  1. Nếu chúng ta thấy định nghĩa của Arrays.asList()phương thức, bạn sẽ nhận được một cái gì đó như thế này:

     public static <T> List<T> asList(T... a) //varargs are of T type. 

    Vì vậy, bạn có thể khởi tạo arraylistnhư thế này:

     List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

    Lưu ý : mỗi new Element(int args)đối tượng sẽ được coi là Đối tượng Cá nhân và có thể được thông qua dưới dạng a var-args.

  2. Có thể có một câu trả lời khác cho câu hỏi này quá.
    Nếu bạn thấy khai báo cho java.util.Collections.addAll()phương thức, bạn sẽ nhận được một cái gì đó như thế này:

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

    Vì vậy, mã này cũng hữu ích để làm như vậy

    Collections.addAll(arraylist, array);

10

Một cách đơn giản khác là thêm tất cả các phần tử từ mảng vào một ArrayList mới bằng cách sử dụng một vòng lặp for-every.

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

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

10

Nếu mảng thuộc kiểu nguyên thủy, các câu trả lời đã cho sẽ không hoạt động. Nhưng vì Java 8, bạn có thể sử dụng:

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

giải pháp này dường như không hoạt động với charmảng.
PixelMaster

8

Bạn có thể làm điều đó trong java 8 như sau

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

1
Bị hạ bệ vì diễn viên đó trông rất nguy hiểm. không có gì xác định rằng loại danh sách được trả về thực sự là một ArrayList, như javadoc tuyên bố: "Không có gì đảm bảo về loại, tính biến đổi, tính tuần tự hoặc tính an toàn của danh sách được trả về"
Dorian Gray

1
Nếu bạn muốn tạo một ArrayList một cách rõ ràng, hãy thử điều này:ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Dorian Gray

8

Chúng ta có thể dễ dàng chuyển đổi một mảng thành ArrayList. Chúng tôi sử dụng addAll()phương pháp của Bộ sưu tập cho mục đích sao chép nội dung từ danh sách này sang danh sách khác.

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

Điều này kém hiệu quả hơn câu trả lời 9 tuổi được chấp nhận.
AjahnCharles

2
Một trong những ArrayListconstructor chấp nhận một ? extends Collection<T>đối số, làm cho cuộc gọi trở addAllnên dư thừa.
Tamoghna Chowdhury

7

Mặc dù có nhiều câu trả lời hoàn hảo bằng văn bản cho câu hỏi này, tôi sẽ thêm đầu vào của mình.

Nói rằng bạn có Element[] array = { new Element(1), new Element(2), new Element(3) };

ArrayList mới có thể được tạo theo các cách sau

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

Và họ hỗ trợ rất tốt mọi hoạt động của 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

Nhưng các hoạt động sau đây chỉ trả về dạng xem Danh sách của ArrayList chứ không phải ArrayList thực tế.

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

Do đó, họ sẽ đưa ra lỗi khi cố gắng thực hiện một số hoạt động ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Thêm về danh sách đại diện của liên kết mảng .


7

Cách đơn giản nhất để làm như vậy là bằng cách thêm mã sau đây. Đã thử và thử nghiệm.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

7

Một giải pháp Java8 khác (tôi có thể đã bỏ lỡ câu trả lời trong tập lớn. Nếu vậy, tôi xin lỗi). Điều này tạo ra một ArrayList (trái ngược với Danh sách), tức là người ta có thể xóa các phần tử

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

Đầu ra là ...
Xin chào
thế giới


7

Sử dụng đoạn mã sau để chuyển đổi một mảng phần tử thành 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]);
}

5

Đã tất cả mọi người đã cung cấp đủ câu trả lời tốt cho vấn đề của bạn. Bây giờ từ tất cả các đề xuất, bạn cần phải quyết định sẽ phù hợp với yêu cầu của bạn. Có hai loại bộ sưu tập mà bạn cần biết. Một là bộ sưu tập chưa sửa đổi và một bộ sưu tập khác sẽ cho phép bạn sửa đổi đối tượng sau này.

Vì vậy, ở đây tôi sẽ đưa ra ví dụ ngắn cho hai trường hợp sử dụng.

  • Tạo bộ sưu tập bất biến :: Khi bạn không muốn sửa đổi đối tượng bộ sưu tập sau khi tạo

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

  • Tạo bộ sưu tập có thể thay đổi :: Khi bạn có thể muốn sửa đổi đối tượng bộ sưu tập đã tạo sau khi tạo.

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


Danh sách <Element> ElementList = Arrays.asList (mảng) tạo ra một trình bao bọc trên mảng ban đầu làm cho mảng ban đầu có sẵn dưới dạng Danh sách. Do đó một đối tượng trình bao được tạo, không có gì được sao chép từ mảng ban đầu. Do đó, các hoạt động như thêm hoặc loại bỏ các yếu tố không được phép.
Priyanka

3
Lưu ý rằng "bộ sưu tập bất biến" của bạn không thực sự bất biến - được Listtrả về Arrays.asListchỉ là một trình bao bọc trên mảng ban đầu và cho phép các mục riêng lẻ được truy cập và sửa đổi thông qua getset. Bạn có thể nên làm rõ rằng bạn có nghĩa là "không thêm hoặc loại bỏ các yếu tố" thay vì "bất biến", có nghĩa là không thay đổi gì cả.
Tamoghna Chowdhury

5

Mảng đối tượng đã cho:

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

Chuyển mảng sang danh sách:

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

Chuyển đổi Array thành ArrayList

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

Chuyển mảng sang LinkedList

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

Danh sách in:

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

ĐẦU RA

1

2

3


4

Lớp Arrays của Java 8 cung cấp một phương thức stream () có các phiên bản quá tải chấp nhận cả mảng nguyên thủy và mảng Object.

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

3

Dưới đây mã có vẻ cách tốt đẹp để làm điều này.

new ArrayList<T>(Arrays.asList(myArray));
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.