Apache Commons'tan CollectionUtils sınıfı

CollectionUtils'e Giriş

Pek çok yararlı yöntem içeren başka bir genel yardımcı program sınıfı:

Bazı yöntemlere bakalım.

Bir koleksiyonun boş olup olmadığını kontrol etmenin yolları

Bir koleksiyonun boş olup olmadığını belirlemenin ne kadar kolay olduğu aşağıda açıklanmıştır:

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

Bir koleksiyonun boş olmadığını kontrol etmek de bir o kadar kolaydır:

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

Örnekler:

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

Apache Commons Collections CollectionUtils Kılavuzu

Kümelerdeki işlemler

Küme teorisiyle uğraşmak zorunda kaldıysanız, kümelerde 4 temel işlem olduğunu bilirsiniz: birleştirme, kesişme, fark ve ayrılma.

Bu işlemler için CollectionUtils sınıfının 4 yöntemi vardır:

• birlik()
• kavşak ()
• ayrılık()
• çıkarma()

Aşağıda bazı basit örnekler verilmiştir:

bir dernek

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]

kavşak

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]

Ayrılık

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]

Fark (kesinti)

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]

Setlerdeki işlemler, devam ediyor

Bu örnek, iki koleksiyonla çalışmak için yukarıdaki dört yöntemin nasıl kullanılacağını gösterir:

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()));

Bizim sonucumuz:

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}

Bu yöntemleri kendi başınıza deneyebilirsiniz.

unmodifiableCollection() Yöntem

Bazen, nesnelerimizin dahili verilerinin koleksiyonlarını döndürmesi gereken arabirim yöntemlerini uygulamamız gerekir. Ve veriler dahili olduğu için kimsenin onu bir yerde değiştirmesini istemiyoruz.

Veya bir yerde değiştirilmesi gerekmeyen, ancak onu üçüncü taraf bir yönteme aktarmaya zorlanan bir koleksiyon aldık. Değiştirmeyeceğinin garantisi nerede?

Huzur içinde uyumak için koleksiyon, koleksiyon değiştirilmeye çalışıldığında bir istisna oluşturacak özel bir paketleyiciye sarılabilir.

Örnek:

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]

Collections.unmodifiableCollection() yöntemi, kendisine iletilen koleksiyon üzerinde bir sarmalayıcı döndürür. Get() , size() yöntemlerini çağırırsanız , her şey çalışacaktır. Ancak, add() , set() , remove() yöntemlerini çağırırken bir istisna alırsınız.

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

Aslında, yöntem zaten kullanımdan kaldırılmış olarak işaretlenmiştir ve bunun yerine Collections.unmodifiableCollection(Collection<? extends T> c) kullanılması önerilir .

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