Bir ArrayList veya String Array öğesinden tüm null öğeleri nasıl kaldırırım?

Böyle bir döngü ile deniyorum

// ArrayList tourists

for (Tourist t : tourists) {
    if (t != null) {     
        t.setId(idForm); 
    }   
}

Ama hoş değil. Biri bana daha iyi bir çözüm önerebilir mi?

Daha iyi karar vermek için bazı yararlı kriterler:

While döngüsü, Döngü ve Yineleyici Performans Testi için

Deneyin:

tourists.removeAll(Collections.singleton(null));

Java API'sini okuyun . Kod, java.lang.UnsupportedOperationExceptiondeğiştirilemeyen listelere (ile oluşturulmuş gibi Arrays.asList) atılacaktır ; bkz bu cevabı daha fazla ayrıntı için.

2015 itibariyle, bu en iyi yoldur (Java 8):

tourists.removeIf(Objects::isNull);

Not: Bu kod, java.lang.UnsupportedOperationExceptiondeğiştirilemeyen listeler dahil olmak üzere sabit boyutlu listeler (Arrays.asList ile oluşturulmuş gibi) için atılacaktır .

list.removeAll(Collections.singleton(null));

Öyle olacak Atar UnsupportedException size vermek çünkü Arrays.asList üzerinde kullanırsanız Immutable o değiştirilemez böylece kopya. Kodun altına bakın. Değişken kopya oluşturur ve herhangi bir istisna atmaz .

public static String[] clean(final String[] v) {
    List<String> list = new ArrayList<String>(Arrays.asList(v));
    list.removeAll(Collections.singleton(null));
    return list.toArray(new String[list.size()]);
}

Verimli değil, kısa

while(tourists.remove(null));

Değişmez veri nesnelerini tercih ediyorsanız veya yalnızca giriş listesine zarar vermek istemiyorsanız, Guava'nın tahminlerini kullanabilirsiniz.

ImmutableList.copyOf(Iterables.filter(tourists, Predicates.notNull()))

 for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Java 8 öncesi kullanmanız gerekenler:

tourists.removeAll(Collections.singleton(null));

Java 8 sonrası kullanım:

tourists.removeIf(Objects::isNull);

Bunun nedeni zaman karmaşıklığı. Dizilerle ilgili sorun, kaldırma işleminin tamamlanması O (n) sürebilir. Gerçekten Java'da bu, boş noktayı değiştirmek için taşınan kalan öğelerin bir dizi kopyasıdır. Burada sunulan diğer birçok çözüm bu sorunu tetikleyecektir. Birincisi teknik olarak O (n * m) 'dir, burada m 1'dir, çünkü tek bir boştur: yani O (n)

Tüm singleton'ları kaldırmalısınız, dahili olarak bir okuma konumu ve bir yazma konumu olan bir batchRemove () yapar. Ve listeyi yineler. Bir null değerine ulaştığında, okuma konumunu 1 ile yineler. Aynı olduklarında geçer, farklı olduklarında değerleri kopyalamaya devam eder. Sonra sonunda boyutuna göre düzeltir.

Bunu dahili olarak etkili bir şekilde yapar:

public static <E> void removeNulls(ArrayList<E> list) {
    int size = list.size();
    int read = 0;
    int write = 0;
    for (; read < size; read++) {
        E element = list.get(read);
        if (element == null) continue;
        if (read != write) list.set(write, element);
        write++;
    }
    if (write != size) {
        list.subList(write, size).clear();
    }
}

Açıkça görebileceğiniz bir O (n) işlemidir.

Daha hızlı olabilen tek şey, listeyi her iki uçtan yinelemeniz ve bir null bulduğunuzda, değerini sonunda bulduğunuz değere eşit olarak ayarlamanız ve bu değeri azaltmanızdır. Ve iki değer eşleşene kadar yinelendi. Siparişi bozarsınız, ancak ayarladığınız değerlerin ve yalnız bıraktığınız değerlerin sayısını büyük ölçüde azaltırsınız. Bu bilmek için iyi bir yöntemdir ama .set () temelde ücretsiz olduğu için burada çok yardımcı olmaz, ancak bu silme şekli kemeriniz için yararlı bir araçtır.

for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Bu yeterince makul görünse de, yineleyicideki .remove () dahili olarak çağırır:

ArrayList.this.remove(lastRet);

Bu yine kaldırmanın içindeki O (n) işlemidir. Hızı önemsiyorsanız, yine istediğinizi olmayan bir System.arraycopy () yapar. Bu n ^ 2 yapar.

Ayrıca:

while(tourists.remove(null));

Hangisi O (m * n ^ 2). Burada sadece listeyi tekrarlamakla kalmıyoruz. Boş ile her eşleştiğimizde listenin tamamını tekrarlıyoruz. Sonra n / 2 (ortalama) işlemleri yapmak için System.arraycopy () kaldırmak gerçekleştirin. Kelimenin tam anlamıyla, tüm koleksiyonu değer içeren öğeler ve boş değerli öğeler arasında sıralayabilir ve bitişi daha kısa sürede kesebilirsiniz. Aslında, bu tüm kırık olanlar için geçerlidir. En azından teoride, gerçek system.arraycopy aslında pratikte bir N operasyonu değildir. Teoride, teori ve pratik aynı şeydir; pratikte değiller.

Tüm nulldeğerleri kaldırmanın kolay bir yolu collectionvar. Null içeren bir koleksiyonu removeAll()metoda parametre olarak geçirmeniz gerekiyor

List s1=new ArrayList();
s1.add(null);

yourCollection.removeAll(s1);

ObjectsSınıf vardır nonNull Predicateile kullanılabileceğini filter.

Örneğin:

tourists.stream().filter(Objects::nonNull).collect(Collectors.toList());

Java 8'i kullanarak stream()ve tuşlarını kullanarak bunu yapabilirsiniz.filter()

tourists = tourists.stream().filter(t -> t != null).collect(Collectors.toList())

veya

tourists = tourists.stream().filter(Objects::nonNull).collect(Collectors.toList())

Daha fazla bilgi için: Java 8 - Akışlar

Arraylist'ten varsayılan null değerleri kaldırmanın kolay yolu

     tourists.removeAll(Arrays.asList(null));  

aksi takdirde dizgiden "null" arraylist kaldır

       tourists.removeAll(Arrays.asList("null"));  

Bununla oynadım ve trimToSize () işlevinin işe yaradığını gördüm. Android platformunda çalışıyorum, bu yüzden farklı olabilir.

Tüm null değerleri kaldırmak için yineleyiciyi kullanabiliriz.

Iterator<Tourist> itr= tourists.iterator();
while(itr.hasNext()){
    if(itr.next() == null){
        itr.remove();
    }
}

Yeni bir liste oluşturmak için akış arabirimini toplama işlemi ve yardımcı bir yöntemle birlikte kullandım.

tourists.stream().filter(this::isNotNull).collect(Collectors.toList());

private <T> boolean isNotNull(final T item) {
    return  item != null;
}

Temelde bu kullanıyorum:

list.removeAll(Collections.singleton(null));

Ama Java 8'i öğrendikten sonra, buna geçtim:

List.removeIf(Objects::isNull);

Kullanımı Java 8 bu akışları, paralel akışları ve kullanan çeşitli şekillerde yapılabilir removeIfyöntem:

List<String> stringList = new ArrayList<>(Arrays.asList(null, "A", "B", null, "C", null));
List<String> listWithoutNulls1 = stringList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
List<String> listWithoutNulls2 = stringList.parallelStream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
stringList.removeIf(Objects::isNull); //[A,B,C]

Paralel akış, mevcut işlemcileri kullanacak ve makul boyutlu listeler için işlemi hızlandıracaktır. Akışları kullanmadan önce her zaman karşılaştırmalı değerlendirme yapılması önerilir.

@Lithium answer öğesine benzer ancak "Liste null türü içeremez" hatası atmaz:

   list.removeAll(Collections.<T>singleton(null));

List<String> colors = new ArrayList<>(
Arrays.asList("RED", null, "BLUE", null, "GREEN"));
// using removeIf() + Objects.isNull()
colors.removeIf(Objects::isNull);