Clasa CollectionUtils de la Apache Commons

Introducere în CollectionUtils

O altă clasă de utilitate generică care conține multe metode utile:

Să ne uităm la câteva metode.

Modalități de a verifica dacă o colecție este goală

Iată cât de ușor este să determinați dacă o colecție este goală:

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

Este la fel de ușor să verifici dacă o colecție nu este goală:

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

Exemple:

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

Un ghid pentru Apache Commons Colecții CollectionUtils

Operații pe platouri

Dacă ai avea de-a face cu teoria mulțimilor, atunci știi că există 4 operații de bază asupra mulțimilor: unire, intersecție, diferență și disjuncție.

Pentru aceste operațiuni, clasa CollectionUtils are 4 metode:

• uniune()
• intersecție()
• disjuncție ()
• scădea()

Mai jos sunt câteva exemple simple:

O asociere

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]

intersecție

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]

Disjuncție

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]

Diferență (deducere)

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]

Operațiuni pe platouri, au continuat

Acest exemplu arată cum să utilizați cele patru metode de mai sus pentru a lucra cu două colecții:

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

Rezultatul nostru:

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}

Puteți experimenta singur aceste metode.

unmodiableCollection() Metoda

Uneori trebuie să implementăm metode de interfață care trebuie să returneze colecții de date interne ale obiectelor noastre. Și din moment ce datele sunt interne, nu vrem ca cineva să le schimbe undeva.

Sau am primit undeva o colecție care nu trebuie schimbată, dar este forțată să o transmitem unei metode terțe. Unde este garanția că nu o va schimba?

Pentru a dormi liniștit, colecția poate fi înfășurată într-un ambalaj special care va face o excepție atunci când încercați să modificați colecția.

Exemplu:

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]

Metoda Collections.unmodifiableCollection() returnează un wrapper peste colecția transmisă acesteia. Dacă îi apelați metodele get() , size() , atunci totul va funcționa. Cu toate acestea, atunci când apelați metodele add() , set() , remove() , veți obține o excepție.

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

De fapt, metoda este deja marcată ca fiind depreciată și este recomandat să utilizați Collections.unmodifiableCollection(Collection<? extends T> c) .

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