Inleiding tot CollectionUtils
Een andere generieke hulpprogrammaklasse die veel handige methoden bevat:
addAll(Verzameling<C> verzameling, C...elementen) | Voegt alle elementen van matrix C toe aan de verzameling |
addIgnoreNull(Verzameling<T> verzameling, T-object) | Voegt een element toe als het niet null is |
bevatAlles(Collectie<?> coll1, Collectie<?> coll2) | Controleert of collectie1 alle elementen van collectie2 bevat |
bevatAny(Collectie<?> coll1, Collectie<?> coll2) | Controleert of collectie1 ten minste één element uit collectie2 bevat |
countMatches(Iterable<C> input, Predikaat<? super C> predikaat) | Telt hoeveel elementen in een verzameling voldoen aan een predikaatregel |
disjunctie (Iterable<? breidt O> a uit, Iterable<? breidt O> b uit) | Retourneert objecten die zich in slechts één verzameling bevinden, maar niet in beide |
intersectie(Iterable<? breidt O> a uit, Iterable<? breidt O> b uit) | Retourneert een verzameling objecten die tegelijkertijd deel uitmaken van beide verzamelingen |
unie(Iterable<? breidt O> a uit, Iterable<? breidt O> b uit) | Retourneert een verzameling objecten die deel uitmaken van ten minste één verzameling |
legeVerzameling() | Retourneert een speciale lege verzameling |
emptyIfNull(Verzameling<T> verzameling) | Retourneert een lege verzameling als verzameling == null |
bestaat (Iterable<C> input, Predikaat<? super C> predikaat) | Controleert of er een element in de verzameling is dat voldoet aan de predikaatregel |
extractSingleton(Verzameling<E> verzameling) | Retourneert het enige element van de verzameling |
filter (Iterable<T> collectie, Predikaat<? super T> predikaat) | Filtert de elementen van een verzameling |
find(Iterable<T> collectie, Predikaat<? super T> predikaat) | Op zoek naar elementen van een verzameling |
isEmpty(Verzameling<?> verzameling) | Controleert of de verzameling leeg is |
isEqualCollection(Verzameling<?> a, Verzameling<?> b) | Vergelijkt collecties |
isFull(Verzameling<? Breidt Object> uit) | Controleert of een element nog aan de verzameling kan worden toegevoegd |
isNotEmpty(Verzameling<?> verzameling) | Controleer of de verzameling niet leeg is |
isSubCollection(Collectie<?> a, Collectie<?> b) | Controleert of verzameling B zich in verzameling A bevindt |
matchesAll(Iterable<C> input, Predikaat<? super C> predikaat) | Controleert of alle elementen van een verzameling voldoen aan een predikaatregel |
removeAll(Collection<E> collection, Collection<?> remove) | Verwijdert alle elementen van de verzameling |
behoudenAlles(Verzameling<C> verzameling, Verzameling<?> behouden) | Retourneert een verzameling die alle elementen van de verzameling bevat die ook in behouden zijn opgenomen |
reverseArray(Object[]-array) | Keert een array achterstevoren om |
unmodifiableCollection(Collection<? breidt C> collectie uit) | Retourneert een wrapper over de collectie. Elke poging om de verzameling te wijzigen, levert een uitzondering op. |
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.
![](https://cdn.codegym.cc/images/article/33592357-0b07-4f2d-ac05-c336539da1cf/800.jpeg)
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);