CodeGym /Java Course /Module 3 /CollectionUtils-klasse van Apache Commons

CollectionUtils-klasse van Apache Commons

Module 3
Niveau 20 , Les 4
Beschikbaar

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.

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);
Opmerkingen
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION