CollectionUtils-klassen fra Apache Commons

Introduktion til CollectionUtils

En anden generisk hjælpeklasse, der indeholder mange nyttige metoder:

Lad os se på nogle metoder.

Måder at kontrollere, om en samling er tom

Her er, hvor nemt det er at afgøre, om en samling er tom:

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

Det er lige så nemt at kontrollere, at en samling ikke er tom:

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

Eksempler:

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

En guide til Apache Commons Collections CollectionUtils

Operationer på sæt

Hvis du skulle beskæftige dig med mængdelære, så ved du, at der er 4 grundlæggende operationer på mængder: forening, skæring, differens og disjunktion.

Til disse operationer har CollectionUtils -klassen 4 metoder:

• Union()
• vejkryds()
• disjunktion()
• trække fra()

Nedenfor er nogle simple eksempler:

En forening

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]

vejkryds

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]

Disjunktion

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]

Forskel (fradrag)

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]

Operationer på sæt, fortsat

Dette eksempel viser, hvordan du bruger ovenstående fire metoder til at arbejde med to samlinger:

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

Vores resultat:

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}

Du kan eksperimentere med disse metoder på egen hånd.

unmodifiableCollection() metode

Nogle gange er vi nødt til at implementere grænseflademetoder, der skal returnere samlinger af vores objekters interne data. Og da dataene er interne, ønsker vi ikke, at nogen skal ændre dem et sted.

Eller vi har modtaget et sted en samling, der ikke skal ændres, men som er tvunget til at videregive den til en tredjepartsmetode. Hvor er garantien for, at han ikke vil ændre det?

For at sove roligt, kan kollektionen pakkes ind i en speciel indpakning, der vil give en undtagelse, når du forsøger at ændre kollektionen.

Eksempel:

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]

Collections.unmodifiableCollection() -metoden returnerer en indpakning over samlingen, der er sendt til den. Hvis du kalder dens get() , size()- metoder , vil alt fungere. Men når du kalder add() , set() , remove() metoderne , får du en undtagelse.

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

Faktisk er metoden allerede markeret som forældet, og det anbefales at bruge Collections.unmodifiableCollection(Collection<? udvider T> c) i stedet for .

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