CollectionUtils-klasse van Apache Commons

Inleiding tot CollectionUtils

Een andere generieke hulpprogrammaklasse die veel handige methoden bevat:

Laten we eens kijken naar enkele methoden.

Manieren om te controleren of een verzameling leeg is

Zo eenvoudig is het om te bepalen of een verzameling leeg is:

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

Het is net zo eenvoudig om te controleren of een verzameling niet leeg is:

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

Voorbeelden:

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

Een gids voor Apache Commons Collections CollectionUtils

Operaties op sets

Als je te maken hebt gehad met verzamelingenleer, dan weet je dat er 4 basisbewerkingen op verzamelingen zijn: unie, intersectie, verschil en disjunctie.

Voor deze bewerkingen heeft de klasse CollectionUtils 4 methoden:

• unie()
• kruispunt()
• disjunctie ()
• aftrekken()

Hieronder staan ​​enkele eenvoudige voorbeelden:

Een associatie

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]

kruispunt

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]

Disjunctie

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]

Verschil (aftrek)

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]

Operaties op sets, voortgezet

Dit voorbeeld laat zien hoe u de bovenstaande vier methoden kunt gebruiken om met twee collecties te werken:

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

Ons resultaat:

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}

U kunt zelf met deze methoden experimenteren.

unmodifiableCollection()-methode

Soms moeten we interfacemethoden implementeren die verzamelingen van de interne gegevens van onze objecten moeten retourneren. En aangezien de gegevens intern zijn, willen we niet dat iemand ze ergens verandert.

Of we hebben ergens een verzameling ontvangen die niet hoeft te worden gewijzigd, maar wordt gedwongen deze door te geven aan een methode van derden. Waar is de garantie dat hij het niet zal veranderen?

Om rustig te kunnen slapen, kan de collectie worden verpakt in een speciale verpakking die een uitzondering vormt bij het proberen de collectie aan te passen.

Voorbeeld:

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]

De methode Collections.unmodifiableCollection() retourneert een wrapper over de collectie die eraan is doorgegeven. Als je de methoden get() , size() aanroept , werkt alles. Wanneer u echter de methoden add() , set() , remove() aanroept , krijgt u een uitzondering.

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

In feite is de methode al gemarkeerd als verouderd en wordt aanbevolen om in plaats daarvan Collections.unmodifiableCollection(Collection<? extends T> c) te gebruiken .

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