CollectionUtils-Klasse von Apache Commons

Einführung in CollectionUtils

Eine weitere generische Dienstprogrammklasse, die viele nützliche Methoden enthält:

Schauen wir uns einige Methoden an.

Möglichkeiten, zu überprüfen, ob eine Sammlung leer ist

So einfach können Sie feststellen, ob eine Sammlung leer ist:

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

Genauso einfach lässt sich überprüfen, ob eine Sammlung nicht leer ist:

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

Beispiele:

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

Ein Leitfaden für Apache Commons Collections CollectionUtils

Operationen an Mengen

Wenn Sie sich mit der Mengenlehre befassen mussten, wissen Sie, dass es vier Grundoperationen für Mengen gibt: Vereinigung, Schnittmenge, Differenz und Disjunktion.

Für diese Vorgänge verfügt die CollectionUtils- Klasse über vier Methoden:

• Union()
• Überschneidung()
• Disjunktion()
• subtrahieren()

Nachfolgend einige einfache Beispiele:

Einen Verband

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]

Überschneidung

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]

Disjunktion

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]

Differenz (Abzug)

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]

Fortsetzung der Operationen an Sets

Dieses Beispiel zeigt, wie Sie die oben genannten vier Methoden verwenden, um mit zwei Sammlungen zu arbeiten:

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

Unser Ergebnis:

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}

Sie können diese Methoden selbst ausprobieren.

unmodifiableCollection() Methode

Manchmal müssen wir Schnittstellenmethoden implementieren, die Sammlungen der internen Daten unserer Objekte zurückgeben müssen. Und da die Daten intern sind, möchten wir nicht, dass jemand sie irgendwo ändert.

Oder wir haben irgendwo eine Sammlung, die nicht geändert werden muss, sind aber gezwungen, sie an eine Methode eines Drittanbieters weiterzugeben. Wo ist die Garantie, dass er es nicht ändern wird?

Um ruhig zu schlafen, kann die Sammlung in einen speziellen Wrapper verpackt werden, der beim Versuch, die Sammlung zu ändern, eine Ausnahme auslöst.

Beispiel:

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]

Die Methode Collections.unmodifiableCollection() gibt einen Wrapper über die ihr übergebene Sammlung zurück. Wenn Sie die Methoden get() und size() aufrufen , funktioniert alles. Wenn Sie jedoch die Methoden add() , set() , remove() aufrufen , erhalten Sie eine Ausnahme.

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

Tatsächlich ist die Methode bereits als veraltet markiert und es wird empfohlen, stattdessen Collections.unmodifiableCollection(Collection<? erweitert T> c) zu verwenden .

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