CollectionUtils osztály az Apache Commonstól

A CollectionUtils bemutatása

Egy másik általános segédprogram, amely számos hasznos módszert tartalmaz:

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ó.

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