Utwórz ArrayList z tablicy

3595

Mam tablicę, która została zainicjowana jak:

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

Chciałbym przekonwertować tę tablicę na obiekt ArrayListklasy.

ArrayList<Element> arraylist = ???;
Ron Tuffin
źródło
49
W Java9 -> List <String> list = List.of („Hello”, „World”, „from”, „Java”);
MarekM
18
@MarekM Ta odpowiedź jest błędna, ponieważ nie zwraca ArrayList. Plakat poprosił o to specjalnie.
Dorian Gray
4
Myślę, że nie używał interfejsu List, ponieważ jest to najlepsza praktyka. Ale jeśli chcesz tutaj - nowa ArrayList <> (List.of („Hello”, „World”, „from”, „Java”));
MarekM
10
Nie chodzi o korzystanie z interfejsu, chodzi o to, że w twoim rozwiązaniu zwrócona lista jest niezmodyfikowana. To może być większy problem i powód, dla którego poprosił o ArrayList
Dorian Gray

Odpowiedzi:

4602
new ArrayList<>(Arrays.asList(array));
Tomek
źródło
361
Tak. A w (najczęstszym) przypadku, gdy chcesz tylko listę, new ArrayListpołączenie również jest niepotrzebne.
Calum
143
@Luron - po prostu użyjList<ClassName> list = Arrays.asList(array)
Pool
247
@Calum i @Pool - jak zauważono poniżej w odpowiedzi Alexa Millera, użycie Arrays.asList(array)bez przekazania go do nowego ArrayListobiektu poprawi rozmiar listy. Jednym z najczęstszych powodów używania an ArrayListjest możliwość dynamicznej zmiany jej rozmiaru, a twoja sugestia by temu zapobiec.
Code Jockey
130
Arrays.asList () jest okropną funkcją i nigdy nie powinieneś po prostu używać jej zwracanej wartości. Łamie szablon Listy, więc zawsze używaj go we wskazanej tutaj formie, nawet jeśli wydaje się zbędny. Dobra odpowiedź.
Adam
83
@Adam Zapoznaj się z javadoc dla java.util.List. Umowa dodawania pozwala im zgłosić wyjątek UnsupportedOperationException. docs.oracle.com/javase/7/docs/api/java/util/... Trzeba przyznać, że z perspektywy obiektowej nie jest zbyt przyjemne, że wiele razy trzeba znać konkretną implementację, aby korzystać z kolekcji - to był pragmatycznym wyborem projektu w celu uproszczenia frameworka.
lbalazscs
918

Dany:

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

Najprostsza odpowiedź to:

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

To zadziała dobrze. Ale niektóre zastrzeżenia:

  1. Lista zwrócona z asList ma ustalony rozmiar . Tak więc, jeśli chcesz mieć możliwość dodawania lub usuwania elementów ze zwróconej listy w kodzie, musisz ją zawinąć w nowy ArrayList. W przeciwnym razie dostaniesz UnsupportedOperationException.
  2. Lista zwracana asList()jest z oryginalnej tablicy. Jeśli zmodyfikujesz oryginalną tablicę, lista również zostanie zmodyfikowana. To może być zaskakujące.
Alex Miller
źródło
6
Jaka jest złożoność czasowa obu operacji? Mam na myśli zi bez użycia jawnej konstrukcji arraylist.
cholera
35
Arrays.asList () tworzy jedynie ArrayList poprzez zawinięcie istniejącej tablicy, tak aby była O (1).
Alex Miller
27
Zawijanie w nowej ArrayList () spowoduje, że wszystkie elementy listy o stałym rozmiarze zostaną iterowane i dodane do nowej ArrayList, podobnie jak O (n).
Alex Miller
8
implementacja List zwrócona przez asList () nie implementuje kilku metod List (takich jak add (), remove (), clear () itp.), co wyjaśnia wyjątek UnsupportedOperationException. zdecydowanie zastrzeżenie ...
sethro
8
Kiedy pytanie dotyczy „obiektu klasy ArrayList”, myślę, że uzasadnione jest przyjęcie klasy, do której się odnosi java.util.ArrayList. Arrays.asList faktycznie zwraca a, java.util.Arrays.ArrayListktóra nie jest instanceofinną klasą. Trzecim zastrzeżeniem jest to, że jeśli spróbujesz użyć go w kontekście wymagającym powyższego, nie zadziała.
Dave L.
352

(stary wątek, ale tylko 2 centy, ponieważ nikt nie wspomina o Guava ani innych bibliotekach i niektórych innych szczegółach)

Jeśli możesz, użyj Guawy

Warto wskazać drogę Guava, która znacznie upraszcza te shenanigany:

Stosowanie

Dla niezmiennej listy

Użyj ImmutableListklasy i jego of()and copyOf()fabryka metod (elementy nie mogą być puste) :

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

Dla Zmiennej Listy

Użyj Listsklasy i jej newArrayList()metod fabrycznych:

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

Należy również zwrócić uwagę na podobne metody dla innych struktur danych w innych klasach, na przykład w Sets.

Dlaczego Guawa?

Główną atrakcją może być zmniejszenie bałaganu ze względu na generyczne czynniki bezpieczeństwa typu, ponieważ zastosowanie fabrycznych metod Guava pozwala na wywnioskowanie typów przez większość czasu. Jednak ten argument zawiera mniej wody, odkąd Java 7 pojawiła się z nowym operatorem diamentów.

Ale to nie jedyny powód (a Java 7 nie jest jeszcze wszędzie): składnia skrócona jest również bardzo przydatna, a inicjalizatory metod, jak pokazano powyżej, pozwalają pisać bardziej ekspresyjny kod. Robisz w jednym wywołaniu Guava, co zajmuje 2 z bieżącymi kolekcjami Java.


Jeśli nie możesz ...

Dla niezmiennej listy

Użyj Arraysklasy JDK i jej asList()metody fabrycznej, opakowanej w Collections.unmodifiableList():

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

Należy pamiętać, że zwracany typ na asList()to Liststosując konkretną ArrayListrealizację, ale to nie jest java.util.ArrayList . Jest to typ wewnętrzny, który emuluje, ArrayListale faktycznie bezpośrednio odwołuje się do przekazanej tablicy i sprawia, że ​​„zapisuje” (modyfikacje są odzwierciedlane w tablicy).

Zabrania modyfikacji niektórych Listmetod interfejsu API poprzez proste rozszerzenie AbstractList(więc dodawanie lub usuwanie elementów nie jest obsługiwane), jednak umożliwia wywołanie set()elementów zastępujących. Tak więc ta lista nie jest naprawdę niezmienne i wywołanie asList()powinno być owinięte Collections.unmodifiableList().

Zobacz następny krok, jeśli potrzebujesz listy zmiennych.

Dla listy zmiennych

Taki sam jak powyżej, ale owinięty rzeczywistym 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+

Do celów edukacyjnych: The Good ol 'Manual Way

// 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);
}
Haylem
źródło
27
+1 Pamiętaj jednak, że Listzwracane przez Arrays.asListjest zmienne, ponieważ nadal możesz zmieniać setelementy - po prostu nie można go zmieniać . W przypadku niezmiennych list bez Guava możesz wspomnieć Collections.unmodifiableList.
Paul Bellora,
1
@haylem W twojej sekcji Dla celów edukacyjnych: dobry stary sposób ręczny , twój arrayToListdla Java 1.5+ jest niepoprawny. Jesteś instanciating list String, i stara się odzyskać sznurki z danej tablicy, zamiast używania ogólny typ parametru T. Poza tym dobra odpowiedź i +1 za bycie jedynym, w tym sposób ręczny.
afsantos
Będę zmieniać nazwę sekcji „Jeśli nie możesz ... / Dla niezmiennej listy” na „Dla niezmodyfikowanej listy”, ponieważ można ją mutować przez późniejsze zmiany w owiniętej tablicy. Nadal jest O(1), ale dla niezmienności musisz wykonać kopię, np Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))). Przez .
maaartinus,
232

Ponieważ to pytanie jest dość stare, zaskakuje mnie to, że nikt jeszcze nie zaproponował najprostszej formy:

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

Począwszy od Java 5, Arrays.asList()pobiera parametr varargs i nie musisz jawnie konstruować tablicy.

Tim Büthe
źródło
7
W szczególnościList<String> a = Arrays.asList("first","second","third")
18446744073709551615,
209
new ArrayList<T>(Arrays.asList(myArray));

Upewnij się, że myArrayjest tego samego typu co T. Otrzymasz błąd kompilatora, jeśli spróbujesz utworzyć na List<Integer>przykład tablicę int.

Bill jaszczurka
źródło
103

Inny sposób (choć zasadniczo równoważny pod względem new ArrayList(Arrays.asList(array))wydajności rozwiązania:

Collections.addAll(arraylist, array);
Peter Tseng
źródło
96

Java 9

W Javie 9 możesz użyć List.ofstatycznej metody fabrycznej, aby utworzyć Listliterał. Coś w stylu:

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

To zwróci niezmienną listę zawierającą trzy elementy. Jeśli chcesz listę zmienną , przekaż tę listę do ArrayListkonstruktora:

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

JEP 269: Wygodne metody fabryczne dla kolekcji

JEP 269 zapewnia kilka fabrycznych metod dla interfejsu API Java Collections . Te niezmienne statyczne metody fabryczne są wbudowane w List, Seti Mapinterfejsów w Javie 9 i nowszych.

Ali Dehghani
źródło
List.of () nie zwróci instancji java.util.ArrayList, zgodnie z żądaniem w pierwotnym pytaniu. Dlatego tylko druga opcja jest prawidłową odpowiedzią.
tquadrat
84

Prawdopodobnie potrzebujesz tylko listy, a nie ArrayList. W takim przypadku możesz po prostu:

List<Element> arraylist = Arrays.asList(array);
Wyrko
źródło
8
Będzie to wspierane przez oryginalną tablicę wejściową, dlatego (prawdopodobnie) chcesz ją zawinąć w nową ArrayList.
Bill the Lizard
16
Uważaj na to rozwiązanie. Jeśli spojrzysz, tablice NIE zwracają prawdziwej java.util.ArrayList. Zwraca klasę wewnętrzną, która implementuje wymagane metody, ale nie można zmienić członków na liście. To tylko opakowanie wokół tablicy.
Mikezx6r
1
Możesz rzucić element List <Element> na ArrayList <Element>
monksy,
12
@ Mikezx6r: mała korekta : to lista o stałym rozmiarze. Możesz zmienić elementy listy ( setmetodę), nie możesz zmienić rozmiaru listy (nie addlub removeelementów)!
user85421,
1
Tak, z zastrzeżeniem, że zależy to od tego, co chcesz zrobić z listą. Warto zauważyć, że jeśli OP po prostu chce iterować po elementach, tablica wcale nie musi być konwertowana.
PaulMurrayCbr
69

Kolejna aktualizacja, prawie kończąca się w 2014 roku, możesz zrobić to również z Javą 8:

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

Uratowałoby się kilka znaków, gdyby to mogła być tylko List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());
dlaczego?
źródło
8
Prawdopodobnie najlepiej nie być zależnym od implementacji, ale w Collectors.toList()rzeczywistości zwraca wartość ArrayList.
bcsb1001,
nieprawidłowe użycie Stream.of (...); które utworzą strumień jednego elementu. Zamiast tego użyj Arrays.stream
Patrick Parker
Nie sądzę, dwie opcje są poprawne, ale Arrays.stream jest nieco „lepszy”, ponieważ można go utworzyć ze stałym rozmiarem, używając metody przeciążenia z argumentami „start”, „end”. Zobacz także: stackoverflow.com/a/27888447/2619091
dlaczego
41

Jeśli użyjesz :

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

Państwo może tworzyć i wypełnić dwie listy! Wypełnianie dwukrotnie dużej listy jest dokładnie tym, czego nie chcesz robić, ponieważ utworzy ona kolejną Object[]tablicę za każdym razem, gdy pojemność musi zostać zwiększona.

Na szczęście implementacja JDK jest szybka i Arrays.asList(a[])bardzo dobrze wykonana. Tworzy rodzaj ArrayList o nazwie Arrays.ArrayList, w którym dane Object [] wskazują bezpośrednio na tablicę.

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

Niebezpieczną stroną jest to, że jeśli zmienisz początkową tablicę, zmienisz listę! Czy na pewno tego chcesz? Może tak, może nie.

Jeśli nie, najbardziej zrozumiałym sposobem jest zrobienie tego:

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

Lub, jak powiedział @glglgl, możesz utworzyć inną niezależną ArrayList za pomocą:

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

Uwielbiam używać Collections, Arrayslub guawy. Ale jeśli to nie pasuje lub nie czujesz tego, po prostu napisz inną nieelegacyjną linię.

Nicolas Zozol
źródło
1
Nie widzę zasadniczej różnicy między twoją pętlą na końcu odpowiedzi a new ArrayList<T>(Arrays.asList(myArray));częścią, której odradzasz używać. Oba robią to samo i mają tę samą złożoność.
glglgl
Jeden z nich tworzy wskaźnik na początku tablicy. Moja pętla tworzy wiele wskaźników: po jednym dla każdego elementu tablicy. Więc jeśli zmieni się pierwotna tablica, moi poinery nadal kierują się do poprzednich wartości.
Nicolas Zozol
1
new ArrayList<T>(Arrays.asList(myArray));robi to samo, kopiuje asListdo ArrayList...
glglgl
37

W Java 9możesz użyć:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
MarekM
źródło
Zauważ, że nie jest to ArrayList, jak zostało to wyraźnie zadane.
Dorian Gray
33

Zgodnie z pytaniem odpowiedź przy użyciu java 1.7 brzmi:

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

Lepiej jednak zawsze używać interfejsu:

List<Element> arraylist = Arrays.<Element>asList(array);
nekperu15739
źródło
30
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
Bohdan
źródło
21

jak wszyscy powiedzieli, to zrobi

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

a powszechnym najnowszym sposobem tworzenia tablicy jest tablice obserwowalne

ObservableList: Lista, która pozwala słuchaczom na śledzenie zmian w momencie ich wystąpienia.

dla Java SE możesz spróbować

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

to jest zgodne z Oracle Docs

observableArrayList () Tworzy nową pustą listę obserwowalną, która jest wspierana przez arraylist. observableArrayList (E ... items) Tworzy nową listę obserwowalnych tablic z dodanymi do niej elementami.

Zaktualizuj Javę 9

także w Javie 9 jest to trochę łatwe:

List<String> list = List.of("element 1", "element 2", "element 3");
Abojemyeg
źródło
20

Od wersji Java 8 istnieje łatwiejszy sposób na transformację:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}
Andrii Abramov
źródło
18

Możesz to również zrobić ze strumieniem w Javie 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
Wazony
źródło
3
Począwszy od java 8 , Collectors.toList()zwróci an ArrayList. Może to jednak różnić się w przyszłych wersjach java.Jeśli chcesz określonego typu kolekcji, użyj Collectors.toCollection()zamiast tego, gdzie możesz określić, jaki dokładnie typ kolekcji chcesz utworzyć.
Raja Anbazhagan
14
  1. Jeśli zobaczymy definicję Arrays.asList()metody, otrzymasz coś takiego:

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

    Więc możesz zainicjować w arraylistten sposób:

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

    Uwaga : każdy new Element(int args)będzie traktowany jako obiekt indywidualny i można go przekazać jako var-args.

  2. Może być też inna odpowiedź na to pytanie.
    Jeśli zobaczysz deklarację java.util.Collections.addAll()metody, otrzymasz coś takiego:

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

    Tak więc ten kod jest również przydatny do tego

    Collections.addAll(arraylist, array);
Vikrant Kashyap
źródło
10

Innym prostym sposobem jest dodanie wszystkich elementów z tablicy do nowej ArrayList za pomocą pętli dla każdego z nich.

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

for(Element e : array)
    list.add(e);
spencer.sm
źródło
10

Jeśli tablica jest typu pierwotnego, podane odpowiedzi nie będą działać. Ale od wersji Java 8 możesz używać:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
A1m
źródło
to rozwiązanie również nie działa z chartablicą.
PixelMaster
8

Możesz to zrobić w Javie 8 w następujący sposób

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
Sztolnia A. Pillai
źródło
1
Odebrano, ponieważ ta obsada wygląda bardzo niebezpiecznie. nic nie wskazuje, że zwracany typ listy jest w rzeczywistości ArrayList, jak stwierdza javadoc: „Nie ma gwarancji co do typu, zmienności, możliwości serializacji lub bezpieczeństwa wątków zwróconej listy”
Dorian Gray
1
Jeśli chcesz jawnie utworzyć ArrayList, spróbuj tego:ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Dorian Gray
8

Możemy łatwo przekonwertować tablicę na ArrayList. Używamy addAll()metody interfejsu Collection w celu kopiowania treści z jednej listy na drugą.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));
rashedcs
źródło
Jest to mniej wydajne niż zaakceptowana odpowiedź z 9 lat.
AjahnCharles
2
Jeden z ArrayListkonstruktorów przyjmuje ? extends Collection<T>argument, powodując wywołanie addAllnadmiaru.
Tamoghna Chowdhury
7

Mimo że istnieje wiele doskonale napisanych odpowiedzi na to pytanie, dodam swoje uwagi.

Powiedz, że masz Element[] array = { new Element(1), new Element(2), new Element(3) };

Nową ArrayList można utworzyć na następujące sposoby

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

I bardzo dobrze obsługują wszystkie operacje 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

Ale następujące operacje zwracają tylko widok listy ArrayList, a nie rzeczywistą ArrayList.

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

Dlatego dadzą błąd podczas próby wykonania niektórych operacji ArrayList

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

Więcej na temat reprezentacji listy linku do tablicy .

Devendra Lattu
źródło
7

Najprostszym sposobem na to jest dodanie następującego kodu. Wypróbowany i przetestowany.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
Hemin
źródło
7

Kolejne rozwiązanie Java8 (mogłem przeoczyć odpowiedź wśród dużego zestawu. Jeśli tak, przepraszam). Tworzy to ArrayList (w przeciwieństwie do List), tzn. Można usuwać elementy

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

Wyjście to ...
Witaj
świecie

Bezzębny Widzący
źródło
7

Użyj poniższego kodu, aby przekonwertować tablicę elementów na 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]);
}
Kavinda Pushpitha
źródło
5

Już wszyscy udzielili wystarczająco dobrej odpowiedzi na problem. Teraz na podstawie wszystkich sugestii musisz zdecydować, który będzie pasował do twoich wymagań. Istnieją dwa rodzaje kolekcji, które musisz znać. Jedna to niezmodyfikowana kolekcja, a druga kolekcja, która pozwoli ci później zmodyfikować obiekt.

Podam więc krótki przykład dwóch przypadków użycia.

  • Niezmienne tworzenie kolekcji :: Gdy nie chcesz modyfikować obiektu kolekcji po utworzeniu

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

  • Zmienne tworzenie kolekcji :: Kiedy możesz zmodyfikować utworzony obiekt kolekcji po utworzeniu.

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

Sumit Das
źródło
List <Element> elementList = Arrays.asList (tablica) tworzy opakowanie nad oryginalną tablicą, która udostępnia oryginalną tablicę jako List. Stąd tworzony jest obiekt otoki, nic nie jest kopiowane z oryginalnej tablicy. Dlatego operacje takie jak dodawanie lub usuwanie elementów są niedozwolone.
Priyanka
3
Zauważ, że twoja „niezmienna kolekcja” nie jest tak naprawdę niezmienna - Listzwracana przez Arrays.asListjest tylko opakowaniem oryginalnej tablicy i pozwala na dostęp i modyfikację poszczególnych elementów za pomocą geti set. Prawdopodobnie powinieneś wyjaśnić, że masz na myśli „nie dodawaj ani nie usuwaj elementów” zamiast „niezmienny”, co oznacza, że ​​wcale się nie zmieniasz.
Tamoghna Chowdhury
5

Dana tablica obiektów:

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

Konwertuj tablicę na listę:

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

Konwertuj tablicę na ArrayList

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

Konwertuj tablicę na LinkedList

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

Drukuj listę:

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

WYNIK

1

2)

3)

Arpan Saini
źródło
4

Klasa Arrays w Javie 8 zapewnia metodę stream (), która ma przeciążone wersje akceptujące zarówno prymitywne tablice, jak i tablice 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());
Himanshu Dave
źródło
3

Poniższy kod wydaje się dobrym sposobem na zrobienie tego.

new ArrayList<T>(Arrays.asList(myArray));
Singh123
źródło