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 = ???;

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

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.

^{(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);
}

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.

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.

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

Collections.addAll(arraylist, array);

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.

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

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

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

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ę.

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

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

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

Możesz dokonać konwersji przy użyciu różnych metod

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

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

Więcej informacji można znaleźć na stronie http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

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

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

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

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

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

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

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

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

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

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

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

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 .

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

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

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

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

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)

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

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

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