Kelas CollectionUtils dari Apache Commons

Pengantar CollectionUtils

Kelas utilitas generik lain yang berisi banyak metode berguna:

Mari kita lihat beberapa metode.

Cara untuk memeriksa apakah koleksi kosong

Inilah betapa mudahnya menentukan apakah suatu koleksi kosong:

CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false

Sama mudahnya untuk memeriksa bahwa koleksi tidak kosong:

CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true

Contoh:

User ivan = new User("Ivan", "ivan@email.com");
User petr = new User("Petr", "petr@email.com");

List<User> users = new ArrayList<>();

System.out.println(CollectionUtils.isEmpty(users)); // true
System.out.println(CollectionUtils.isNotEmpty(users)); // false

users.add(ivan);
users.add(petr);

System.out.println(CollectionUtils.isEmpty(users)); // false
System.out.println(CollectionUtils.isNotEmpty(users)); // true

users = null;
System.out.println(CollectionUtils.isEmpty(users)); // true
System.out.println(CollectionUtils.isNotEmpty(users)); // false

Panduan untuk Koleksi Apache Commons CollectionUtils

Operasi pada set

Jika Anda harus berurusan dengan teori himpunan, maka Anda tahu bahwa ada 4 operasi dasar pada himpunan: penyatuan, irisan, selisih, dan disjungsi.

Untuk operasi ini, kelas CollectionUtils memiliki 4 metode:

• Persatuan()
• persimpangan()
• pemisahan()
• mengurangi()

Di bawah ini adalah beberapa contoh sederhana:

Sebuah asosiasi

List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");

//combine two sets
Collection<String> result = CollectionUtils.union(firstList, secondList);
System.out.println(ArrayUtils.toString(result));     //[1, 2, 3, 4, 5, 6, 7, 8, 9]

persimpangan

List<String> firstList = Arrays.asList("A", "B", "C", "D", "E", "F");
List<String> secondList = Arrays.asList("B", "D", "F", "G", "H", "K");

//intersections of two sets
Collection<String> result = CollectionUtils.intersection(firstList, secondList);
System.out.println(ArrayUtils.toString(result));     //[B, D, F]

Pemisahan

List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");

//disjunction
Collection<String> result = CollectionUtils.disjunction(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); //[1, 4, 5, 7, 8, 9]

Selisih (pengurangan)

List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");

//difference
Collection<String> result = CollectionUtils.subtract(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); // [1, 4, 5]

Operasi pada set, lanjutan

Contoh ini menunjukkan cara menggunakan empat metode di atas untuk bekerja dengan dua koleksi:

List<Integer> firstList = Arrays.asList(1, 2, 3, 3, 4, 5);
List<Integer> secondList = Arrays.asList(3, 4, 4, 5, 6, 7);

Collection<Integer> union = CollectionUtils.union(firstList, secondList); // An association
Collection<Integer> intersection = CollectionUtils.intersection(firstList, secondList); // Intersection
Collection<Integer> disjunction = CollectionUtils.disjunction(firstList, secondList); // disjunction
Collection<Integer> subtract = CollectionUtils.subtract(firstList, secondList); // Difference

System.out.println("firstList: " + ArrayUtils.toString(firstList.toArray()));
System.out.println("secondList: " + ArrayUtils.toString(secondList.toArray()));

System.out.println("An association: " + ArrayUtils.toString(union.toArray()));
System.out.println("Intersection: " + ArrayUtils.toString(intersection.toArray()));
System.out.println("Disjunction: " + ArrayUtils.toString(disjunction.toArray()));
System.out.println("Difference: " + ArrayUtils.toString(subtract.toArray()));

Hasil kami:

firstList: {1,2,3,3,4,5}
secondList: {3,4,4,5,6,7}
An association: {1,2,3,3,4,4,5,6,7}
intersection: {3,4,5}
Disjunction: {1,2,3,4,6,7}
Difference: {1,2,3}

Anda dapat bereksperimen dengan metode ini sendiri.

unmodifiableCollection() Metode

Terkadang kita perlu mengimplementasikan metode antarmuka yang perlu mengembalikan kumpulan data internal objek kita. Dan karena datanya internal, kami tidak ingin siapa pun mengubahnya di suatu tempat.

Atau kami telah menerima koleksi di suatu tempat yang tidak perlu diubah, tetapi dipaksa untuk meneruskannya ke beberapa metode pihak ketiga. Di manakah jaminan bahwa dia tidak akan mengubahnya?

Untuk tidur nyenyak, koleksi dapat dibungkus dengan pembungkus khusus yang akan mengeluarkan pengecualian saat mencoba memodifikasi koleksi.

Contoh:

Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection = Collections.unmodifiableCollection(firstCollection);
firstCollection.add("hello");
firstCollection.add("from");
firstCollection.add("codeGym");

//secondCollection.add("have a error");
System.out.println(secondCollection); //[hello, from, codeGym]

Metode Collections.unmodifiableCollection() mengembalikan pembungkus atas koleksi yang diteruskan ke sana. Jika Anda memanggil metode get() , size() , maka semuanya akan berfungsi. Namun, saat memanggil metode add() , set() , remove() , Anda akan mendapatkan pengecualian.

java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)

Faktanya, metode ini sudah ditandai sebagai usang dan disarankan untuk menggunakan Collections.unmodifiableCollection(Collection<? extends T> c) sebagai gantinya .

Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);