Introduksjon til CollectionUtils
En annen generisk verktøyklasse som inneholder mange nyttige metoder:
addAll(Samling<C>-samling, C...elementer) | Legger til alle elementene i array C til samlingen |
addIgnoreNull(Samling<T>-samling, T-objekt) | Legger til et element hvis det ikke er null |
containsAll(Samling<?> koll1, Samling<?> koll2) | Sjekker at samling1 inneholder alle elementene i samling2 |
containsAny(Collection<?> coll1, Collection<?> coll2) | Sjekker at samling1 inneholder minst ett element fra samling2 |
countMatches(Iterable<C> input, Predicate<? super C> predikat) | Teller hvor mange elementer i en samling som tilfredsstiller en predikatregel |
disjunksjon(Iterable<? forlenger O> a, Iterable<? forlenger O> b) | Returnerer objekter som er i bare én samling, men ikke begge |
skjæringspunkt(Iterable<? forlenger O> a, Iterable<? forlenger O> b) | Returnerer en samling av objekter som er en del av begge samlingene samtidig |
union(Iterable<? forlenger O> a, Iterable<? forlenger O> b) | Returnerer en samling av objekter som er del av minst én samling |
emptyCollection() | Returnerer en spesiell tom samling |
emptyIfNull(Samling<T> samling) | Returnerer en tom samling hvis samling == null |
eksisterer (Itererbar<C>-inngang, predikat<? super C>-predikat) | Sjekker om det er et element i samlingen som tilfredsstiller predikatregelen |
extractSingleton(Collection<E> collection) | Returnerer det eneste elementet i samlingen |
filter(Iterable<T>-samling, Predikat<? super T>-predikat) | Filtrerer elementene i en samling |
find(Iterable<T>-samling, Predikat<? super T>-predikat) | Ser etter elementer i en samling |
isEmpty(Samling<?> samling) | Sjekker om samlingen er tom |
isEqualCollection(Samling<?> a, Samling<?> b) | Sammenligner samlinger |
isFull(Samling<? utvider Objekt> kolli) | Sjekker om et element fortsatt kan legges til samlingen |
isNotEmpty(Samling<?> samling) | Sjekk om samlingen ikke er tom |
isSubCollection(Samling<?> a, Samling<?> b) | Sjekker om samling B er i samling A |
matchesAll(Iterable<C> input, Predicate<? super C> predikat) | Sjekker at alle elementer i en samling tilfredsstiller en predikatregel |
removeAll(Samling<E> samling, Samling<?> fjern) | Fjerner alle elementer i samlingen |
retainAll(Collection<C> collection, Collection<?> retain) | Returnerer en samling som inneholder alle elementer av samlingen som også er inneholdt i retain |
reverseArray(Objekt[] array) | Reverserer en matrise bakover |
unmodifiableCollection(Samling<? utvider C>-samlingen) | Returnerer et omslag over samlingen. Ethvert forsøk på å endre samlingen vil gi et unntak. |
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.
![](https://cdn.codegym.cc/images/article/33592357-0b07-4f2d-ac05-c336539da1cf/800.jpeg)
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);