Classe CollectionUtils da Apache Commons

Introduzione a CollectionUtils

Un'altra classe di utilità generica che contiene molti metodi utili:

Diamo un'occhiata ad alcuni metodi.

Modi per verificare se una raccolta è vuota

Ecco quanto è facile determinare se una raccolta è vuota:

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

È altrettanto facile verificare che una raccolta non sia vuota:

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

Esempi:

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

Una guida alle raccolte di Apache Commons CollectionUtils

Operazioni sugli insiemi

Se hai avuto a che fare con la teoria degli insiemi, allora sai che ci sono 4 operazioni fondamentali sugli insiemi: unione, intersezione, differenza e disgiunzione.

Per queste operazioni, la classe CollectionUtils ha 4 metodi:

• unione()
• intersezione()
• disgiunzione()
• sottrarre()

Di seguito alcuni semplici esempi:

Un'associazione

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]

intersezione

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]

Disgiunzione

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]

Differenza (deduzione)

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]

Continuano le operazioni sui set

Questo esempio mostra come utilizzare i quattro metodi precedenti per lavorare con due raccolte:

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

Il nostro risultato:

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}

Puoi sperimentare questi metodi da solo.

metodo unmodifiableCollection()

A volte abbiamo bisogno di implementare metodi di interfaccia che devono restituire raccolte di dati interni dei nostri oggetti. E poiché i dati sono interni, non vogliamo che nessuno li modifichi da qualche parte.

Oppure abbiamo ricevuto da qualche parte una raccolta che non ha bisogno di essere modificata, ma è costretta a passarla a un metodo di terze parti. Dov'è la garanzia che non lo cambierà?

Per dormire sonni tranquilli, la raccolta può essere racchiusa in uno speciale involucro che genererà un'eccezione quando si tenta di modificare la raccolta.

Esempio:

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]

Il metodo Collections.unmodifiableCollection() restituisce un wrapper sulla raccolta che gli è stata passata. Se chiami i suoi metodi get() , size() , allora tutto funzionerà. Tuttavia, quando chiami i metodi add() , set() , remove() , otterrai un'eccezione.

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

Infatti, il metodo è già contrassegnato come deprecato e si consiglia di utilizzare invece Collections.unmodifiableCollection(Collection<? extends T> c) .

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