Diziyi Java'da listeye dönüştürme

Bir diziyi Java'daki bir listeye nasıl dönüştürebilirim?

Ben kullandım Arrays.asList()ama davranış (ve imza) bir şekilde Java SE 1.4.2 (şimdi arşivde dokümanlar) 8 ve web üzerinde bulunan çoğu snippet'leri 1.4.2 davranış kullanın değişti .

Örneğin:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)

• 1.4.2'de 1, 2, 3 öğelerini içeren bir liste döndürür
• 1.5.0+ sürümünde spam dizisini içeren bir liste döndürür

Birçok durumda tespit edilmesi kolay olmalıdır, ancak bazen fark edilmeden kayabilir:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

Örneğinizde, bunun nedeni ilkel tipte bir Listeniz olamaz. Başka bir deyişle, List<int>mümkün değildir.

Ancak, bir olabilir List<Integer>kullanılarak Integersarar sınıfı intilkel. Bir şekilde diziyi dönüştürme Listile Arrays.asListyarar yöntemiyle.

Integer[] spam = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(spam);

IdeOne.com adresinde canlı olarak çalıştırılan bu koda bakın .

Java 8'de akışları kullanabilirsiniz:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

Dönüşüm yolu hakkında konuşmak, neden ihtiyacınız olduğuna bağlıdır List. Sadece veri okumak için ihtiyacınız varsa. Tamam, hadi bakalım:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Ama sonra böyle bir şey yaparsanız:

list.add(1);

olsun java.lang.UnsupportedOperationException. Yani bazı durumlarda buna bile ihtiyacınız var:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

İlk yaklaşım aslında diziyi dönüştürmez, ancak 'gibi' temsil eder List. Ancak dizi, sabit sayıda eleman gibi tüm özellikleri ile kaputun altındadır. İnşa ederken türü belirtmeniz gerektiğini lütfen unutmayın ArrayList.

Sorun, varargs'ın Java5'te tanıtılması ve maalesef Arrays.asList()bir vararg sürümü ile aşırı yüklenmesi. Böylece Arrays.asList(spam)int dizilerin bir vararg parametresi olarak Java5 derleyici tarafından anlaşılmaktadır.

Bu sorun, Etkili Java 2nd Ed., Bölüm 7, Madde 42'de daha ayrıntılı olarak açıklanmaktadır.

Biraz geç görünüyor ama işte benim iki sentim. Biz olamaz List<int>olarak intbiz sadece olabilir böylece ilkel türüdür List<Integer>.

Java 8 (int dizisi)

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 ve altı (Tamsayı dizisi)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Listeye değil ArrayList'e mi ihtiyacınız var?

Belirli bir uygulamanın ListÖrnegin asagidaki ArrayListgibi kullanabiliriz toCollection:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Neden list21yapısal olarak değiştirilemiyor?

Arrays.asListDöndürülen listenin boyutunu kullandığımızda , geri dönen liste olmadığı için sabitjava.util.ArrayList , içinde tanımlanan özel bir statik sınıfjava.util.Arrays . Dolayısıyla, döndürülen listeye öğe ekler veya listeden öğe kaldırırsak, bir UnsupportedOperationExceptionatılır. Bu yüzden list22listeyi değiştirmek istediğimizde gitmeliyiz . Java8'imiz varsa o zaman da gidebiliriz list23.

Açık olmak gerekirse list21 olmak gerekirse, arayabileceğimiz anlamda değiştirilebilir, list21.set(index,element)ancak bu liste yapısal olarak değiştirilemez, yani listeye öğe ekleyemez veya listeden öğe kaldıramaz. Bu soruyu da kontrol edebilirsiniz .

Değişmez bir liste istiyorsak, onu şu şekilde sarabiliriz:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

Dikkat edilmesi gereken bir diğer nokta, yöntemin Collections.unmodifiableListbelirtilen listenin değiştirilemez bir görünümünü döndürmesidir. Değiştirilemez bir görünüm koleksiyonu değiştirilemeyen ve aynı zamanda bir destek koleksiyonunun bir görünümüdür. Destek koleksiyonunda değişikliklerin hala mümkün olabileceğini ve gerçekleşmeleri durumunda değiştirilemeyen görünümden görülebileceğini unutmayın.

Java 9 ve 10'da gerçekten değişmez bir listeye sahip olabiliriz.

Gerçekten Değişmez liste

Java 9:

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

Java 10 (Gerçekten Değişmez liste):

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

Ayrıca daha fazla bilgi için bu cevabımı kontrol edin .

Daha da kısa:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

Son zamanlarda bir diziyi bir listeye dönüştürmek zorunda kaldım. Daha sonra program, verileri kaldırmaya çalışan listeyi filtreledi. Arrays.asList (array) işlevini kullandığınızda, sabit boyutlu bir koleksiyon oluşturursunuz: ne ekleyebilir ne de silebilirsiniz. Bu girdi, sorunu yapabileceğimden daha iyi açıklıyor: Neden bir öğeyi listeden kaldırmaya çalışırken bir UnsupportedOperationException alıyorum? .

Sonunda, bir "manuel" dönüşüm yapmak zorunda kaldım:

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

List.addAll (items) işlemi kullanarak bir diziden bir listeye dönüşüm ekledi olabilir varsayalım.

Dizileri Kullanma

Bu, bir diziyi dönüştürmenin en basit yoludur List. Ancak, yeni bir öğe eklemeye veya varolan bir öğeyi listeden kaldırmaya çalışırsanız bir UnsupportedOperationExceptionatılır.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

ArrayList veya Diğer Liste Uygulamalarını Kullanma

forDizinin tüm öğelerini bir Listuygulamaya eklemek için bir döngü kullanabilirsiniz , örneğin ArrayList:

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Java 8'de Stream API kullanma

Diziyi bir akışa dönüştürebilir, ardından farklı toplayıcıları kullanarak akışı toplayabilirsiniz: Java 8'deki varsayılan toplayıcı ArrayListekranın arkasında kullanılır , ancak tercih ettiğiniz uygulamayı da uygulayabilirsiniz.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Ayrıca bakınız:

• Java'da neden otomatik kutulama ve kutudan çıkarma kullanıyoruz?
• LinkedList ne zaman ArrayList üzerinde kullanılır?

Apache commons-lang kullanıyorsanız başka bir geçici çözüm:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

Nerede ArrayUtils.toObject dönüştürür int[]içinInteger[]

diziye girmelisin

Arrays.asList((Object[]) array)

Tek astarı:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

Java 9'da, yeni kolaylık fabrika yöntemi ile değişmez listeleri kullanmanın daha zarif bir çözümüne sahipsiniz List.of:

List<String> immutableList = List.of("one","two","three");

(utanmadan buradan kopyalandı )

Java 8'i (veya daha yenisini) hedefliyorsanız, bunu deneyebilirsiniz:

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

NOT:

Dikkat edin Collectors.<Integer>toList(), bu jenerik yöntem hatası ": dönüştürmek olamaz Tür uyuşmazlığı önlemek için yardımcı List<Object>için List<Integer>".

1. Guava'yı kullanma:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);

2. Apache Commons Koleksiyonlarını Kullanma:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = new ArrayList<>(6);
   CollectionUtils.addAll(list, array);

Bu yardımcı olursa: Ben aynı sorunu yaşadım ve sadece bir dizi alır ve aynı içeriğe sahip aynı türden bir ArrayList döndüren genel bir işlev yazdım:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

Verilen Dizi:

    int[] givenArray = {2,2,3,3,4,5};

Tamsayı dizisini Tamsayı Listesine dönüştürme

Tek yönlü: boxed () -> IntStream öğesini döndürür

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

İkinci Yol: Akışın her bir öğesini Tamsayı ile eşleyin ve ardından toplayın

NOT: mapToObj komutunu kullanarak, her int öğesini i (char) i'ye muhafaza ederek dize akışına, char akışına vb.

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

Bir dizi Tipini Başka Bir Tipe Dönüştürme Örnek:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Bu yüzden hangi Java sürümüne çalıştığınıza bağlıdır.

Java 7

 Arrays.asList(1, 2, 3);

VEYA

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

VEYA

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

Java 8'de

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

Referans - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Bu yanıtı geliştirebilir misiniz lütfen bu benim kullandığım ama% 100 net değilim. İyi çalışıyor ancak intelliJ yeni WeatherStation [0] ekledi. Neden 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

diziyi tam sayı değerinde kullanırsanız, ilkel veri türü için otomatik boks türünü kullanmanız gerekir.

  Integer [] arr={1,2};
  Arrays.asList(arr);