Cara Menapis Koleksi di Java

1. Gambaran keseluruhan

Dalam tutorial ringkas ini, kita akan melihat pelbagai cara menyaring Koleksi di Java - iaitu mencari semua item yang memenuhi syarat tertentu.

Ini adalah tugas asas yang terdapat dalam hampir semua aplikasi Java.

Atas sebab ini, jumlah perpustakaan yang menyediakan fungsi untuk tujuan ini adalah signifikan.

Terutama, dalam tutorial ini kita akan membahas:

  • Fungsi penapis ( 8) Java 8 Streams
  • Pemungut penapisan Java 9
  • API Koleksi Eclipse yang berkaitan
  • Kaedah penapis CollectionUtils Apache ()
  • Pendekatan penapis Koleksi2 Jambu Batu ()

2. Menggunakan Aliran

Sejak Java 8 diperkenalkan, Stream telah mendapatkan peran penting dalam banyak kasus di mana kita harus memproses pengumpulan data.

Oleh itu, ini adalah pendekatan yang disukai dalam kebanyakan kes kerana ia dibina di Jawa dan tidak memerlukan pergantungan tambahan.

2.1. Menapis Koleksi dengan Aliran

Demi kesederhanaan, dalam semua contoh-contoh objektif kami adalah untuk mewujudkan satu kaedah yang mendapatkan semula hanya nombor walaupun dari Collection of Integer nilai.

Oleh itu, kita dapat menyatakan keadaan yang akan kita gunakan untuk menilai setiap item sebagai ' nilai% 2 == 0 '.

Dalam semua kes, kita harus menentukan keadaan ini sebagai objek Predikat :

public Collection findEvenNumbers(Collection baseCollection) { Predicate streamsPredicate = item -> item % 2 == 0; return baseCollection.stream() .filter(streamsPredicate) .collect(Collectors.toList()); }

Penting untuk diperhatikan bahawa setiap perpustakaan yang kita analisis dalam tutorial ini menyediakan pelaksanaan Predicate sendiri , tetapi tetap saja, semuanya didefinisikan sebagai antara muka fungsional, oleh itu membolehkan kita menggunakan fungsi Lambda untuk menyatakannya.

Dalam kes ini, kami menggunakan Pengumpul yang telah ditentukan sebelumnya yang disediakan oleh Java yang mengumpulkan unsur-unsur ke dalam Senarai , tetapi kami mungkin telah menggunakan yang lain, seperti yang dibincangkan dalam catatan sebelumnya.

2.2. Menyaring Setelah Mengumpulkan Koleksi di Java 9

Aliran membolehkan kita mengagregat item menggunakan pengumpulan groupingBy .

Namun, jika kita menyaring seperti yang kita lakukan di bahagian terakhir, beberapa elemen mungkin akan dibuang pada peringkat awal, sebelum pengumpul ini dimainkan.

Atas sebab ini, yang menapis pengumpul diperkenalkan dengan Java 9, dengan objektif untuk memproses subcollections selepas mereka telah dikumpulkan.

Mengikuti contoh kami, bayangkan kami ingin mengumpulkan kumpulan kami berdasarkan bilangan digit yang dimiliki oleh Integer, sebelum menyaring nombor ganjil:

public Map
    
      findEvenNumbersAfterGrouping( Collection baseCollection) { Function getQuantityOfDigits = item -> (int) Math.log10(item) + 1; return baseCollection.stream() .collect(groupingBy( getQuantityOfDigits, filtering(item -> item % 2 == 0, toList()))); }
    

Ringkasnya, jika kita menggunakan pengumpul ini, kita mungkin berakhir dengan entri nilai kosong, sedangkan jika kita menapis sebelum mengelompokkan, pengumpul sama sekali tidak akan membuat entri seperti itu.

Sudah tentu, kami akan memilih pendekatan berdasarkan keperluan kami.

3. Menggunakan Koleksi Eclipse

Kami juga dapat menggunakan beberapa perpustakaan pihak ketiga yang lain untuk mencapai tujuan kami, sama ada kerana aplikasi kami tidak menyokong Java 8 atau kerana kami ingin memanfaatkan beberapa fungsi hebat yang tidak disediakan oleh Java.

Seperti halnya Eclipse Collections , sebuah perpustakaan yang berusaha untuk mengikuti paradigma baru, berkembang dan merangkumi perubahan yang diperkenalkan oleh semua rilis Java terbaru.

Kita boleh mulakan dengan meneroka entri Pengenalan Koleksi Eclipse kami untuk mempunyai pengetahuan yang lebih luas mengenai fungsi yang disediakan oleh perpustakaan ini.

3.1. Kebergantungan

Mari mulakan dengan menambahkan kebergantungan berikut ke pom.xml projek kami :

 org.eclipse.collections eclipse-collections 9.2.0 

Koleksi gerhana merangkumi semua antara muka struktur data yang diperlukan dan API itu sendiri.

3.2. Menapis Koleksi dengan Koleksi Eclipse

Sekarang mari kita gunakan fungsi penapisan gerhana pada salah satu struktur datanya, seperti MutableListnya :

public Collection findEvenNumbers(Collection baseCollection) { Predicate eclipsePredicate = item -> item % 2 == 0; Collection filteredList = Lists.mutable .ofAll(baseCollection) .select(eclipsePredicate); return filteredList; }

Sebagai alternatif, kita boleh telah menggunakan Iterate 's pilih ()kaedah statik untuk menentukan objek filteredList :

Collection filteredList = Iterate.select(baseCollection, eclipsePredicate);

4. Menggunakan Koleksi Util Apache

Untuk memulakan dengan perpustakaan CollectionUtils Apache , kita dapat melihat tutorial ringkas ini di mana kita merangkumi penggunaannya.

Akan tetapi, dalam tutorial ini, kita akan memfokuskan pada implementasi filternya () .

4.1. Kebergantungan

Pertama, kita memerlukan kebergantungan berikut dalam fail pom.xml kami :

 org.apache.commons commons-collections4 4.2 

4.2. Menapis Koleksi dengan CollectionUtils

Kami kini bersedia menggunakan kaedah CollectonUtils :

public Collection findEvenNumbers(Collection baseCollection) { Predicate apachePredicate = item -> item % 2 == 0; CollectionUtils.filter(baseCollection, apachePredicate); return baseCollection; }

Kita harus mengambil kira bahawa kaedah ini mengubah baseCollection dengan membuang setiap item yang tidak sesuai dengan syarat.

Ini bermakna bahawa Koleksi asas harus diubah, jika tidak, ia akan membuat pengecualian .

5. Menggunakan Koleksi Jambu Batu2

Seperti sebelumnya, kita dapat membaca catatan sebelumnya 'Menapis dan Mengubah Koleksi di Jambu Batu' untuk maklumat lebih lanjut mengenai perkara ini.

5.1. Kebergantungan

Mari mulakan dengan menambahkan kebergantungan ini dalam fail pom.xml kami :

 com.google.guava guava 25.1-jre 

5.2. Menapis Koleksi dengan Koleksi2

As we can see, this approach is fairly similar to the one followed in the last section:

public Collection findEvenNumbers(Collection baseCollection) { Predicate guavaPredicate = item -> item % 2 == 0; return Collections2.filter(baseCollection, guavaPredicate); }

Again, here we define a Guava specific Predicate object.

In this case, Guava doesn't modify the baseCollection, it generates a new one, so we can use an immutable collection as input.

6. Conclusion

In summary, we've seen that there are many different ways of filtering collections in Java.

Even though Streams are usually the preferred approach, its good to know and keep in mind the functionality offered by other libraries.

Especially if we need to support older Java versions. However, if this is the case, we need to keep in mind recent Java features used throughout the tutorial such as lambdas should be replaced with anonymous classes.

Seperti biasa, kita dapat menemui semua contoh yang ditunjukkan dalam tutorial ini di repo Github kami.