Ben gibi başlatılan bir dizi var:

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

Bu diziyi ArrayListsınıfın bir nesnesine dönüştürmek istiyorum .

ArrayList<Element> arraylist = ???;

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

Verilen:

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

En basit cevap:

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

Bu iyi çalışır. Ancak bazı uyarılar:

1. AsList'ten döndürülen listenin boyutu sabittir . Bu nedenle, kodunuzdaki döndürülen listeye öğe eklemek veya listeden öğe kaldırmak istiyorsanız, yeni bir listeye sarmanız gerekir ArrayList. Aksi takdirde UnsupportedOperationException.
2. Döndürülen liste asList()orijinal dizi tarafından desteklenir. Orijinal diziyi değiştirirseniz, liste de değiştirilir. Bu şaşırtıcı olabilir.

^{(eski iş parçacığı, ama hiçbiri Guava veya diğer kütüphanelerden ve diğer bazı ayrıntılardan bahsetmediği gibi sadece 2 sent)}

Yapabiliyorsanız, Guava Kullanın

Bu maskaralıkları büyük ölçüde basitleştiren Guava yolunu belirtmeye değer:

kullanım

Değişmez Bir Liste İçin

Kullanım ImmutableListsınıfını ve onun of()ve copyOf()fabrika yöntemleri ^{(elementler null olamaz)} :

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

Değişken Listesi İçin

ListsSınıfı ve newArrayList()fabrika yöntemlerini kullanı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

Lütfen diğer sınıflardaki diğer veri yapıları için de benzer yöntemleri not edin, örneğin Sets.

Neden Guava?

Ana cazibe, Guava fabrika yöntemlerinin kullanımı türlerin çoğu zaman çıkarılmasına izin verdiği için, tip güvenliği için jeneriklerden kaynaklanan dağınıklığı azaltmak olabilir . Ancak, Java 7 yeni elmas operatörüne geldiğinden bu argüman daha az su tutar.

Ancak tek neden bu değil (ve Java 7 henüz her yerde değil): steno sözdizimi de çok kullanışlıdır ve yukarıda görüldüğü gibi yöntem başlatıcıları daha anlamlı kod yazmanıza izin verir. Geçerli Java Koleksiyonları ile 2 alan bir Guava çağrısı yaparsınız.

Yapamazsan ...

Değişmez Bir Liste İçin

JDK'nın Arrayssınıfını ve aşağıdakilerle asList()sarılmış fabrika yöntemini kullanın Collections.unmodifiableList():

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

İçin döndürülen tip unutmayın asList()bir olan Listbir beton kullanarak ArrayListuygulama ama o değil java.util.ArrayList . Bu, öykünen öykünen ArrayListancak aslında doğrudan geçirilen diziye başvuruda bulunan ve "yazarak" yapan değişikliklerdir (değişiklikler diziye yansıtılır).

ListAPI'nın bazı yöntemlerinde yalnızca bir genişletme yoluyla değişiklik yapılmasını yasaklar AbstractList(böylece, öğe ekleme veya kaldırma desteklenmez), ancak set()öğelerin geçersiz kılınmasına yönelik çağrılara izin verir . Bu yüzden bu liste tam olarak değişmez değildir ve bir çağrı asList()ile sarılmalıdır Collections.unmodifiableList().

Değiştirilebilir bir listeye ihtiyacınız varsa bir sonraki adıma bakın.

Değişken Listesi İçin

Yukarıdaki ile aynı, ancak gerçek bir ile sarılmış 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+

Eğitim Amaçlı: Manuel Olmanın İyi Yolu

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

Bu soru oldukça eski olduğundan, kimsenin henüz en basit formu önermediği beni şaşırtıyor:

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

Java 5'ten itibaren Arrays.asList()bir varargs parametresi alır ve diziyi açıkça yapılandırmanız gerekmez.

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

Bunun myArraytürüyle aynı olduğundan emin olun T. Örneğin List<Integer>bir diziden bir oluşturmaya çalışırsanız derleyici hatası alırsınız int.

Başka bir yol (esasen new ArrayList(Arrays.asList(array))performans açısından çözümle eşdeğer olmasına rağmen :

Collections.addAll(arraylist, array);

Java 9

In Java 9 kullanabileceğiniz List.ofbir yaratmak için statik fabrika yöntemi Listdeğişmezi. Aşağıdaki gibi bir şey:

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

Bu, üç öğe içeren değişmez bir liste döndürür . Değiştirilebilir bir liste istiyorsanız , bu listeyi yapıcıya iletinArrayList :

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

JEP 269: Koleksiyonlar için Kullanışlı Fabrika Yöntemleri

JEP 269 , Java Koleksiyonlar API'sı için bazı kullanışlı fabrika yöntemleri sağlar . Bunlar değişmez statik fabrika yöntemleri yerleşik olarak List, Setve Mapdaha sonra Java 9 ve arayüzler.

Muhtemelen bir Listeye ihtiyacınız vardır, ArrayList'e değil. Bu durumda şunları yapabilirsiniz:

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

2014 yılını neredeyse biten başka bir güncelleme, Java 8 ile de yapabilirsiniz:

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

Birkaç karakter kaydedilebilir, eğer bu sadece List

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

Eğer kullanırsan :

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

Eğer açabilir oluşturmak ve dolgu iki listeleri! Büyük bir listeyi iki kez doldurmak, yapmak istemediğiniz şeydir, çünkü Object[]kapasitenin her genişletilmesi gerektiğinde başka bir dizi oluşturacaktır .

Neyse ki JDK uygulaması hızlı ve Arrays.asList(a[])çok iyi. Object [] verilerinin doğrudan diziyi işaret ettiği Arrays.ArrayList adlı bir tür ArrayList oluşturur.

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

Tehlikeli tarafı, ilk diziyi değiştirirseniz List!Bunu istediğinden emin misin? Belki evet belki hayır.

Değilse, en anlaşılır yol bunu yapmaktır:

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

Ya da @glglgl dediğimiz gibi, bağımsız bir ArrayList oluşturabilirsiniz:

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

Ben kullanmayı seven Collections, Arraysya Guava. Ama uymuyorsa veya hissetmiyorsanız, bunun yerine başka bir yetersiz satır yazın.

Şunlarda Java 9kullanabilirsiniz:

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

Soruya göre java 1.7 kullanarak cevap:

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

Ancak her zaman arayüzü kullanmak daha iyidir:

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

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

Farklı yöntemler kullanarak dönüştürebilirsiniz

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

Daha fazla ayrıntı için http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html adresine başvurabilirsiniz.

herkesin söylediği gibi bu

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

ve dizi oluşturmanın en yaygın yolu gözlenebilirdir.

ObservableList: Dinleyicilerin değişiklikleri gerçekleştiğinde izlemelerine izin veren bir liste.

Java SE için deneyebilirsiniz

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

Oracle Docs'a göre

obsableArrayList () Bir arraylist tarafından desteklenen yeni, boş, gözlenebilir bir liste oluşturur. obsableArrayList (E ... öğeleri) Öğeye eklenen yeni bir gözlemlenebilir dizi listesi oluşturur.

Java 9'u Güncelle

Java 9'da da biraz kolay:

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

Java 8'den bu yana dönüştürmenin daha kolay bir yolu var:

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

Ayrıca Java 8'de akışla da yapabilirsiniz.

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

1. Arrays.asList()Yöntemin tanımını görürsek şöyle bir şey elde edersiniz:

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

   Yani, şu şekilde başlatabilirsiniz arraylist:

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

   Not : her biri new Element(int args)Bireysel Nesne olarak değerlendirilir ve bir olarak geçirilebilir var-args.

2. Bu soru için başka bir cevap daha olabilir. Yöntem
   için bir bildirim görürseniz java.util.Collections.addAll()şöyle bir şey elde edersiniz:

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

   Bu nedenle, bu kod da yararlıdır

   Collections.addAll(arraylist, array);

Diğer bir basit yol, for-each döngüsünü kullanarak dizideki tüm öğeleri yeni bir ArrayList'e eklemektir.

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

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

Dizi ilkel türdeyse verilen yanıtlar çalışmaz. Ancak Java 8'den beri şunları kullanabilirsiniz:

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

Java 8'de aşağıdaki gibi yapabilirsiniz

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

Bir diziyi kolayca dönüştürebiliriz ArrayList. addAll()İçeriği bir listeden diğerine kopyalamak için Koleksiyon arayüzünün yöntemini kullanıyoruz .

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

Bu soruya mükemmel şekilde yazılmış çok sayıda cevap olmasına rağmen, girdilerimi ekleyeceğim.

Söyle var Element[] array = { new Element(1), new Element(2), new Element(3) };

Yeni ArrayList aşağıdaki şekillerde oluşturulabilir

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

Ve ArrayList'in tüm operasyonlarını çok iyi destekliyorlar

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

Ancak aşağıdaki işlemler, gerçek ArrayList'in değil, yalnızca bir ArrayList öğesinin Liste görünümünü döndürür.

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

Bu nedenle, bazı ArrayList işlemleri yapmaya çalışırken hata verecektir

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

Dizi bağlantısının liste gösterimi hakkında daha fazla bilgi .

Bunu yapmanın en basit yolu aşağıdaki kodu eklemektir. Denendi ve test edildi.

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

Başka bir Java8 çözümü (Büyük set arasında cevabı kaçırmış olabilirim. Öyleyse özür dilerim). Bu, bir ArrayList oluşturur (bir Listenin aksine), yani öğeleri silebilir

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

Çıktı ...
Merhaba
dünya

Bir öğe dizisini ArrayList'e dönüştürmek için aşağıdaki kodu kullanın.

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

Zaten herkes sorununuz için yeterince iyi cevap verdi. Şimdi tüm önerilerden, hangisinin gereksiniminize uyacağına karar vermeniz gerekiyor. Bilmeniz gereken iki tür koleksiyon vardır. Biri değiştirilmemiş koleksiyon ve diğeri ise nesneyi daha sonra değiştirmenize izin verecektir.

Burada iki kullanım örneği için kısa bir örnek vereceğim.

• Değişmez koleksiyon oluşturma :: Oluşturma işleminden sonra koleksiyon nesnesini değiştirmek istemediğinizde

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

• Değişken koleksiyon oluşturma :: Oluşturulduktan sonra oluşturulan koleksiyon nesnesini değiştirmek istediğinizde.

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

Verilen Nesne Dizisi:

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

Diziyi Listeye Dönüştür:

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

Diziyi ArrayList'e Dönüştür

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

Diziyi LinkedList'e Dönüştür

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

Listeyi Yazdır:

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

ÇIKTI

1

2

3

Java 8'in Arrays sınıfı, hem ilkel dizileri hem de Nesne dizilerini kabul eden aşırı yüklenmiş sürümlere sahip bir stream () yöntemi sağlar.

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

Aşağıdaki kod bunu yapmak için güzel bir yol gibi görünüyor.

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