CollectionUtils-klassen fra Apache Commons

Introduksjon til CollectionUtils

En annen generisk verktøyklasse som inneholder mange nyttige metoder:

La oss se på noen metoder.

Måter å sjekke om en samling er tom

Her er hvor enkelt det er å finne ut 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 like enkelt å sjekke 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

Operasjoner på sett

Hvis du måtte forholde deg til settteori, så vet du at det er 4 grunnleggende operasjoner på sett: union, skjæringspunkt, forskjell og disjunksjon.

For disse operasjonene har CollectionUtils -klassen 4 metoder:

• union()
• kryss()
• disjunksjon()
• trekke fra()

Nedenfor er noen enkle 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]

kryss

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]

Disjunksjon

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]

Differanse (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]

Operasjoner på sett, fortsatt

Dette eksemplet viser hvordan du bruker de fire metodene ovenfor for å jobbe 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()));

Resultatet vårt:

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 metodene på egen hånd.

unmodifiableCollection() Metode

Noen ganger må vi implementere grensesnittmetoder som må returnere samlinger av objektenes interne data. Og siden dataene er interne, vil vi ikke at noen skal endre dem et sted.

Eller vi har mottatt et sted en samling som ikke trenger å endres, men som er tvunget til å overføre den til en tredjepartsmetode. Hvor er garantien for at han ikke vil endre det?

For å sove fredelig, kan samlingen pakkes inn i en spesiell innpakning som vil gi et unntak når du prøver å endre samlingen.

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 wrapper over samlingen som er sendt til den. Hvis du kaller dens get() , size()- metoder , vil alt fungere. Men når du kaller add() , set() , remove()- metodene , vil du få et unntak.

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

Faktisk er metoden allerede merket som utdatert, og det anbefales å bruke Collections.unmodifiableCollection(Collection<? utvider T> c) i stedet .

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