Cara Memfilter Koleksi di Java

1. Ikhtisar

Dalam tutorial singkat ini, kita akan melihat berbagai cara untuk memfilter Koleksi di Java - yaitu, menemukan semua item yang memenuhi kondisi tertentu.

Ini adalah tugas mendasar yang ada di hampir semua aplikasi Java.

Untuk alasan ini, jumlah pustaka yang menyediakan fungsionalitas untuk tujuan ini menjadi signifikan.

Secara khusus, dalam tutorial ini kita akan membahas:

  • Fungsi filter () Java 8 Streams
  • Kolektor pemfilteran Java 9
  • API Koleksi Eclipse yang Relevan
  • Metode Apache's CollectionUtils filter ()
  • Guava's Collections2 filter () pendekatan

2. Menggunakan Streams

Sejak Java 8 diperkenalkan, Streams telah mendapatkan peran kunci dalam banyak kasus saat kami harus memproses kumpulan data.

Akibatnya, ini adalah pendekatan yang disukai dalam banyak kasus karena dibangun di Java dan tidak memerlukan dependensi tambahan.

2.1. Memfilter Koleksi dengan Aliran

Demi kesederhanaan, di semua contoh tujuan kami adalah untuk menciptakan sebuah metode yang mengambil hanya nomor bahkan dari Koleksi dari Integer nilai-nilai.

Jadi, kita dapat mengekspresikan kondisi yang akan kita gunakan untuk mengevaluasi setiap item sebagai ' nilai% 2 == 0 '.

Dalam semua kasus, kita harus mendefinisikan kondisi ini sebagai objek Predicate :

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

Penting untuk dicatat bahwa setiap pustaka yang kita analisis dalam tutorial ini menyediakan implementasi Predicate -nya sendiri , tetapi tetap saja, semuanya didefinisikan sebagai antarmuka fungsional, oleh karena itu memungkinkan kita menggunakan fungsi Lambda untuk mendeklarasikannya.

Dalam hal ini, kami menggunakan Kolektor yang telah ditentukan sebelumnya yang disediakan oleh Java yang mengumpulkan elemen ke dalam Daftar , tetapi kami dapat menggunakan yang lain, seperti yang dibahas di posting sebelumnya ini.

2.2. Memfilter Setelah Mengelompokkan Koleksi di Java 9

Aliran memungkinkan kita untuk mengumpulkan item menggunakan kolektor groupingBy .

Namun, jika kita memfilter seperti yang kita lakukan di bagian terakhir, beberapa elemen mungkin akan dibuang di tahap awal, sebelum kolektor ini mulai berfungsi.

Untuk alasan ini, yang menyaring kolektor diperkenalkan dengan Java 9, dengan tujuan memproses subkoleksi setelah mereka telah dikelompokkan.

Mengikuti contoh kita, mari kita bayangkan kita ingin mengelompokkan koleksi kita berdasarkan jumlah digit yang dimiliki setiap Integer, sebelum memfilter angka 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()))); }
    

Singkatnya, jika kita menggunakan kolektor ini, kita mungkin berakhir dengan entri nilai kosong, sedangkan jika kita memfilter sebelum pengelompokan, kolektor tidak akan membuat entri seperti itu sama sekali.

Tentu saja, kami akan memilih pendekatan berdasarkan kebutuhan kami.

3. Menggunakan Koleksi Eclipse

Kami juga dapat menggunakan beberapa pustaka pihak ketiga lainnya untuk mencapai tujuan kami, baik jika itu karena aplikasi kami tidak mendukung Java 8 atau karena kami ingin memanfaatkan beberapa fungsionalitas canggih yang tidak disediakan oleh Java.

Seperti kasus Koleksi Eclipse , perpustakaan yang berusaha untuk mengikuti paradigma baru, berkembang dan merangkul perubahan yang diperkenalkan oleh semua rilis Java terbaru.

Kita bisa mulai dengan menjelajahi pos Pengenalan Koleksi Eclipse untuk memiliki pengetahuan yang lebih luas tentang fungsi yang disediakan oleh perpustakaan ini.

3.1. Dependensi

Mari kita mulai dengan menambahkan ketergantungan berikut ke pom.xml proyek kita :

 org.eclipse.collections eclipse-collections 9.2.0 

Koleksi gerhana mencakup semua antarmuka struktur data yang diperlukan dan API itu sendiri.

3.2. Memfilter Koleksi dengan Koleksi Eclipse

Sekarang mari kita gunakan fungsi pemfilteran eclipse pada salah satu struktur datanya, seperti MutableList :

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

Sebagai alternatif, kita sudah bisa digunakan para Iterate 's pilih ()metode statis untuk menentukan objek filteredList :

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

4. Menggunakan CollectionUtils Apache

Untuk memulai dengan pustaka CollectionUtils Apache , kita dapat melihat tutorial singkat ini di mana kita membahas penggunaannya.

Dalam tutorial ini, bagaimanapun, kita akan fokus pada implementasi filter () .

4.1. Dependensi

Pertama, kita membutuhkan dependensi berikut di file pom.xml kita :

 org.apache.commons commons-collections4 4.2 

4.2. Filtering a Collection with CollectionUtils

We are now ready to use the CollectonUtils‘ methods:

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

We have to take into account that this method modifies the baseCollection by removing every item that doesn't match the condition.

This means that the base Collection has to be mutable, otherwise it will throw an exception.

5. Using Guava's Collections2

As before, we can read our previous post ‘Filtering and Transforming Collections in Guava' for further information on this subject.

5.1. Dependencies

Let's start by adding this dependency in our pom.xml file:

 com.google.guava guava 25.1-jre 

5.2. Filtering a Collection with Collections2

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, kami dapat menemukan semua contoh yang ditampilkan dalam tutorial ini di repo Github kami.