A CollectionUtils bemutatása
Egy másik általános segédprogram, amely számos hasznos módszert tartalmaz:
addAll(Gyűjtemény<C> gyűjtemény, C...elemek) | A C tömb összes elemét hozzáadja a gyűjteményhez |
addIgnoreNull(gyűjtemény<T> gyűjtemény, T objektum) | Hozzáad egy elemet, ha az nem null |
tartalmazzaMindent(gyűjtemény<?> gyűjtemény1, gyűjtemény<?> gyűjtemény2) | Ellenőrzi, hogy a collection1 tartalmazza-e a collection2 összes elemét |
tartalmazzaAny(gyűjtemény<?> gyűjtemény1, gyűjtemény<?> gyűjtemény2) | Ellenőrzi, hogy a gyűjtemény1 tartalmaz-e legalább egy elemet a 2. gyűjteményből |
countMatches (Iterálható<C> bemenet, Predikátum<? Super C> predikátum) | Megszámolja, hogy egy gyűjtemény hány eleme felel meg egy predikátumszabálynak |
diszjunkció (Iterálható<? kiterjeszti O> a, Iterable<? kiterjeszti O> b) | Olyan objektumokat ad vissza, amelyek csak egy gyűjteményben vannak, de nem mindkettőben |
metszéspont(Iterálható<? kiterjeszti O> a, Iterálható<? kiterjeszti O> b) | Olyan objektumok gyűjteményét adja vissza, amelyek egyszerre mindkét gyűjtemény részét képezik |
union(Iterálható<? kiterjeszti O> a, Iterable<? kiterjeszti O> b) | Olyan objektumok gyűjteményét adja vissza, amelyek legalább egy gyűjtemény részét képezik |
üres gyűjtemény() | Egy különleges üres gyűjteményt ad vissza |
emptyIfNull(gyűjtemény<T> gyűjtemény) | Üres gyűjteményt ad vissza, ha a gyűjtemény == null |
létezik (Iterálható<C> bemenet, Predikátum<? szuper C> predikátum) | Ellenőrzi, hogy van-e olyan elem a gyűjteményben, amely megfelel az állítmányszabálynak |
kivonatSingleton(gyűjtemény<E> gyűjtemény) | A gyűjtemény egyetlen elemét adja vissza |
szűrő (Iterálható<T> gyűjtemény, Predikátum<? szuper T> predikátum) | Szűri a gyűjtemény elemeit |
find(Iterálható<T> gyűjtemény, Predikátum<? szuper T> predikátum) | Egy gyűjtemény elemeit keresem |
isEmpty(Gyűjtemény<?> kollekció) | Ellenőrzi, hogy a gyűjtemény üres-e |
isEqualCollection(gyűjtemény<?> a, gyűjtemény<?> b) | Összehasonlítja a gyűjteményeket |
isFull(Gyűjtemény<? kiterjeszti az Object> coll) | Ellenőrzi, hogy egy elem hozzáadható-e még a gyűjteményhez |
isNotEmpty(Gyűjtemény<?> kollekció) | Ellenőrizze, hogy a gyűjtemény nem üres-e |
isSubCollection(gyűjtemény<?> a, gyűjtemény<?> b) | Ellenőrzi, hogy a B gyűjtemény az A gyűjteményben van-e |
matchesAll(Iterable<C> bemenet, Predikátum<? Super C> predikátum) | Ellenőrzi, hogy egy gyűjtemény minden eleme megfelel-e egy predikátumszabálynak |
RemoveAll(Gyűjtemény<E> gyűjtemény, Gyűjtemény<?> eltávolítás) | Eltávolítja a gyűjtemény összes elemét |
megtartaniAll(gyűjtemény<C> gyűjtemény, gyűjtemény<?> megtartása) | Egy gyűjteményt ad vissza, amely tartalmazza a gyűjtemény összes elemét, amely szintén szerepel a megtartásban |
reverseArray(Object[] tömb) | Visszafelé fordít egy tömböt |
unmodifiableCollection(A gyűjtemény<? kiterjeszti a C> gyűjteményt) | Burkolatot ad vissza a gyűjteményre. A gyűjtemény módosítására tett kísérlet kivételt jelent. |
Nézzünk néhány módszert.
A gyűjtemény ürességének ellenőrzésének módjai
Így könnyen megállapítható, hogy egy gyűjtemény üres-e:
CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false
Ugyanilyen egyszerű ellenőrizni, hogy egy gyűjtemény nem üres-e:
CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true
Példák:
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
Útmutató az Apache Commons Collections CollectionUtils-hez
Műveletek a készleteken
Ha halmazelmélettel kellett foglalkoznia, akkor tudja, hogy a halmazokon 4 alapművelet létezik: egyesülés, metszés, különbség és diszjunkció.
![](https://cdn.codegym.cc/images/article/33592357-0b07-4f2d-ac05-c336539da1cf/800.jpeg)
Ezekhez a műveletekhez a CollectionUtils osztály 4 metódussal rendelkezik:
- unió()
- útkereszteződés()
- diszjunkció ()
- kivon()
Íme néhány egyszerű példa:
Egy egyesület
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]
útkereszteződés
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]
Diszjunkció
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]
Különbség (levonás)
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]
Műveletek a díszleteken, folytatódott
Ez a példa bemutatja, hogyan használhatja a fenti négy módszert két gyűjtemény kezelésére:
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()));
Eredményünk:
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}
Ezekkel a módszerekkel egyedül is kísérletezhet.
unmodifiableCollection() metódus
Néha olyan interfész-módszereket kell megvalósítanunk, amelyeknek vissza kell adniuk az objektumaink belső adatainak gyűjteményeit. És mivel az adatok belsőek, nem szeretnénk, ha bárki megváltoztatná valahol.
Vagy kaptunk valahol egy olyan gyűjteményt, amelyet nem kell megváltoztatni, de kénytelenek átadni valamilyen harmadik fél módszerének. Hol a garancia, hogy nem változtat?
A nyugodt alvás érdekében a kollekciót be lehet csomagolni egy speciális csomagolásba, amely kivételt jelent, amikor megpróbálja módosítani a kollekciót.
Példa:
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]
A Collections.unmodifiableCollection() metódus egy burkolót ad vissza a neki átadott gyűjtemény felett. Ha meghívod a get() , size() metódusait , akkor minden működni fog. Az add() , set() , remove() metódusok meghívásakor azonban kivételt kapunk.
java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)
Valójában a metódus már elavultként van megjelölve, és javasolt helyette a Collections.unmodifiableCollection(Collection<? extends T> c) használata .
Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);