Introducere în CollectionUtils
O altă clasă de utilitate generică care conține multe metode utile:
addAll(Colecție<C> colecție, C...elemente) | Adaugă toate elementele matricei C la colecție |
addIgnoreNull(Colecție<T>, obiect T) | Adaugă un element dacă nu este nul |
containsAll(Colecție<?> coll1, Colecție<?> coll2) | Verifică dacă colecția1 conține toate elementele colecției2 |
conţineOrice(Colecţie<?> coll1, Colecţie<?> coll2) | Verifică dacă colecția1 conține cel puțin un element din colecția2 |
countMatches(Intrare iterabilă<C>, predicat<? super C> predicat) | Numărează câte elemente dintr-o colecție satisfac o regulă de predicat |
disjuncție (Iterable<? extinde O> a, Iterable<? extinde O> b) | Returnează obiecte care se află într-o singură colecție, dar nu ambele |
intersecție (Iterable<? extinde O> a, Iterable<? extinde O> b) | Returnează o colecție de obiecte care fac parte din ambele colecții simultan |
unire(Iterable<? extinde O> a, Iterable<? extinde O> b) | Returnează o colecție de obiecte care fac parte din cel puțin o colecție |
emptyCollection() | Returnează o colecție specială goală |
emptyIfNull(Colecție<T>) | Returnează o colecție goală dacă colecția == nulă |
există (intrare iterabilă<C>, predicat<? super C> predicat) | Verifică dacă există un element în colecție care satisface regula predicatului |
extractSingleton(Colecție<E> colecție) | Returnează singurul element al colecției |
filtru (colecție Iterable<T>, predicat <? super T> predicat) | Filtrează elementele unei colecții |
find(colecția Iterable<T>, predicat<? super T> predicat) | În căutarea elementelor unei colecții |
isEmpty(Colecție<?> col.) | Verifică dacă colecția este goală |
isEqualCollection(Colecție<?> a, Colecție<?> b) | Compară colecțiile |
isFull(Collection<? extins Object> coll) | Verifică dacă un element mai poate fi adăugat la colecție |
isNotEmpty(Colecție<?> col.) | Verificați dacă colecția nu este goală |
isSubCollection(Colecție<?> a, Colecție<?> b) | Verifică dacă colecția B se află în colecția A |
matchsAll(Iterable<C> intrare, predicat<? super C> predicat) | Verifică dacă toate elementele unei colecții îndeplinesc o regulă de predicat |
removeAll(Colecție<E> colecție, Colecție<?> eliminare) | Elimină toate elementele colecției |
retainAll(Colecție<C> colecție, Colecție<?> reține) | Returnează o colecție care conține toate elementele colecției care sunt, de asemenea, conținute în retain |
reverseArray(Matrice obiect[]) | Inversează o matrice înapoi |
unmodiableCollection(Colecție<? extinde colecția C>) | Returnează un înveliș peste colecție. Orice încercare de a modifica colecția va arunca o excepție. |
Să ne uităm la câteva metode.
Modalități de a verifica dacă o colecție este goală
Iată cât de ușor este să determinați dacă o colecție este goală:
CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false
Este la fel de ușor să verifici dacă o colecție nu este goală:
CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true
Exemple:
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
Un ghid pentru Apache Commons Colecții CollectionUtils
Operații pe platouri
Dacă ai avea de-a face cu teoria mulțimilor, atunci știi că există 4 operații de bază asupra mulțimilor: unire, intersecție, diferență și disjuncție.
![](https://cdn.codegym.cc/images/article/33592357-0b07-4f2d-ac05-c336539da1cf/800.jpeg)
Pentru aceste operațiuni, clasa CollectionUtils are 4 metode:
- uniune()
- intersecție()
- disjuncție ()
- scădea()
Mai jos sunt câteva exemple simple:
O asociere
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]
intersecție
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]
Disjuncție
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]
Diferență (deducere)
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]
Operațiuni pe platouri, au continuat
Acest exemplu arată cum să utilizați cele patru metode de mai sus pentru a lucra cu două colecții:
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()));
Rezultatul nostru:
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}
Puteți experimenta singur aceste metode.
unmodiableCollection() Metoda
Uneori trebuie să implementăm metode de interfață care trebuie să returneze colecții de date interne ale obiectelor noastre. Și din moment ce datele sunt interne, nu vrem ca cineva să le schimbe undeva.
Sau am primit undeva o colecție care nu trebuie schimbată, dar este forțată să o transmitem unei metode terțe. Unde este garanția că nu o va schimba?
Pentru a dormi liniștit, colecția poate fi înfășurată într-un ambalaj special care va face o excepție atunci când încercați să modificați colecția.
Exemplu:
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]
Metoda Collections.unmodifiableCollection() returnează un wrapper peste colecția transmisă acesteia. Dacă îi apelați metodele get() , size() , atunci totul va funcționa. Cu toate acestea, atunci când apelați metodele add() , set() , remove() , veți obține o excepție.
java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)
De fapt, metoda este deja marcată ca fiind depreciată și este recomandat să utilizați Collections.unmodifiableCollection(Collection<? extends T> c) .
Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);