Klasa CollectionUtils z Apache Commons

Wprowadzenie do CollectionUtils

Kolejna ogólna klasa narzędzi zawierająca wiele przydatnych metod:

Przyjrzyjmy się niektórym metodom.

Sposoby sprawdzania, czy kolekcja jest pusta

Oto jak łatwo ustalić, czy kolekcja jest pusta:

CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false

Równie łatwo jest sprawdzić, czy kolekcja nie jest pusta:

CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true

Przykłady:

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

Przewodnik po kolekcjach Apache Commons CollectionUtils

Operacje na zbiorach

Jeśli miałeś do czynienia z teorią mnogości, to wiesz, że istnieją 4 podstawowe operacje na zbiorach: suma, przecięcie, różnica i alternatywna.

Dla tych operacji klasa CollectionUtils ma 4 metody:

• unia()
• skrzyżowanie()
• dysjunkcja()
• odejmować()

Poniżej kilka prostych przykładów:

Stowarzyszenie

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]

skrzyżowanie

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]

Dysjunkcja

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]

Różnica (odliczenie)

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]

Działania na zbiorach, ciąg dalszy

Ten przykład pokazuje, jak używać powyższych czterech metod do pracy z dwiema kolekcjami:

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

Nasz wynik:

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}

Możesz samodzielnie eksperymentować z tymi metodami.

unmodifiedCollection() Metoda

Czasami musimy zaimplementować metody interfejsu, które muszą zwracać kolekcje wewnętrznych danych naszych obiektów. A ponieważ dane są wewnętrzne, nie chcemy, aby ktoś je gdzieś zmieniał.

Lub mamy gdzieś kolekcję, której nie trzeba zmieniać, ale jesteśmy zmuszeni przekazać ją jakiejś metodzie innej firmy. Gdzie jest gwarancja, że ​​tego nie zmieni?

Aby spać spokojnie, kolekcję można opakować w specjalne opakowanie, które przy próbie modyfikacji kolekcji wyrzuci wyjątek.

Przykład:

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.unmodifyingCollection() zwraca opakowanie nad przekazaną do niej kolekcją. Jeśli wywołasz metody get() , size() , wszystko będzie działać. Jednak podczas wywoływania metod add() , set() , remove() otrzymasz wyjątek.

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

W rzeczywistości metoda jest już oznaczona jako przestarzała i zaleca się zamiast niej użycie Collections.unmodifyingCollection(Collection<? extends T> c) .

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