CollectionUtils-klass från Apache Commons

Introduktion till CollectionUtils

En annan generisk verktygsklass som innehåller många användbara metoder:

Låt oss titta på några metoder.

Sätt att kontrollera om en samling är tom

Så här lätt är det att avgöra om en samling är tom:

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

Det är lika enkelt att kontrollera att en samling inte är tom:

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

Exempel:

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 till Apache Commons Collections CollectionUtils

Operationer på uppsättningar

Om du var tvungen att hantera mängdlära, då vet du att det finns 4 grundläggande operationer på mängder: union, skärningspunkt, skillnad och disjunktion.

För dessa operationer har CollectionUtils -klassen fyra metoder:

• union()
• genomskärning()
• åtskiljande()
• subtrahera()

Nedan följer några enkla exempel:

En förening

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]

genomskärning

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]

Åtskiljande

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]

Skillnad (avdrag)

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]

Operationer på uppsättningar, fortsättning

Det här exemplet visar hur du använder de fyra ovanstående metoderna för att arbeta med två samlingar:

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

Vårt resultat:

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 experimentera med dessa metoder på egen hand.

unmodifiableCollection() metod

Ibland behöver vi implementera gränssnittsmetoder som behöver returnera samlingar av våra objekts interna data. Och eftersom informationen är intern vill vi inte att någon ska ändra den någonstans.

Eller så har vi någonstans fått en samling som inte behöver ändras, utan som tvingas skicka den till någon tredjepartsmetod. Var finns garantin att han inte kommer att ändra det?

För att sova lugnt kan kollektionen slås in i ett speciellt omslag som kommer att göra ett undantag när man försöker modifiera kollektionen.

Exempel:

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]

Metoden Collections.unmodifiableCollection() returnerar ett omslag över samlingen som skickas till den. Om du anropar dess get() , size() -metoder , kommer allt att fungera. Men när du anropar metoderna add() , set() , remove() får du ett undantag.

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

Faktum är att metoden redan är markerad som utfasad och det rekommenderas att använda Collections.unmodifiableCollection(Collection<? förlänger T> c) istället .

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