Commons Collections 简明教程 :: 计算机编程技术中文文档库

Apache Commons Collections - Quick Guide

Apache Commons Collections - Overview

Commons 集合扩展了 Java 集合框架。它提供了若干功能，以简化集合处理。它提供了许多新的接口、实现和实用工具。

Commons 集合的主要功能如下：

Bag - Bag 接口简化了集合，其中每个对象都有多个副本。
BidiMap - BidiMap 接口提供了双向映射，可以使用键查找值，或使用值查找键。
MapIterator - MapIterator 接口提供了对映射的简单轻松的迭代。
Transforming Decorators - 转换装饰器可以更改集合中每个对象的类型，并且在将对象添加到集合中时才进行更改。
Composite Collections - 使用复合集合来统一地处理多个集合。
Ordered Map - 有序映射保留了将元素添加进去时的顺序。
Ordered Set - 有序集合保留了将元素添加进去时的顺序。
Reference map - 引用映射允许在严格的控制下对键/值进行垃圾回收。
Comparator implementations - 提供了许多比较器实现。
Iterator implementations - 提供了许多迭代器实现。
Adapter Classes - 提供适配器类将数组和枚举转换为集合。
Utilities - 提供实用工具来测试或创建集合的典型集合理论属性，如并集、交集。支持闭包。

Commons Collections - Environment Setup

Local Environment Setup

如果您仍然愿意为 Java 编程语言设置您的环境，则本节指导您如何在您的机器上下载并设置 Java。请按照下面提到的步骤设置环境。

Java SE 可以从 www.oracle.com/technetwork/java/archive-139210.html 链接免费获得。因此，您可以根据自己的操作系统下载一个版本。

按照说明下载 Java 并运行 .exe 以在您的机器上安装 Java。在您的机器上安装 Java 后，您需要设置环境变量以指向正确的安装目录。

Setting up the Path for Windows 2000/XP

我们假设您已在 c:\Program Files\java\jdk directory 中安装了 Java。

右键单击“我的电脑”，然后选择“属性”。
单击“高级”选项卡下的“环境变量”按钮。
现在，更改“路径”变量，使其也包含 Java 可执行文件的路径。例如，如果当前路径设置为 'C:\WINDOWS\SYSTEM32' ，则更改路径为 'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin' 。

Setting up the Path for Windows 95/98/ME

我们假设您已在 c:\Program Files\java\jdk directory 中安装了 Java。

编辑“C:\autoexec.bat”文件，并在末尾添加以下行： 'SET PATH=%PATH%;C:\Program Files\java\jdk\bin' 。

Setting up the Path for Linux, UNIX, Solaris, FreeBSD

应设置环境变量 PATH 来指向 Java 二进制文件安装的位置。如果您遇到困难，请参阅您的 Shell 文档。

例如，如果您使用 bash 作为您的 Shell，则您需要将以下行添加到您的 .bashrc: export PATH=/path/to/java:$PATH' 的末尾：

Popular Java Editors

要编写 Java 程序，您需要一个文本编辑器。市场中有许多高级集成开发环境可用。但目前，您可以考虑以下选项之一 −

Notepad − 在 Windows 机器上，您可以使用任何简单的文本编辑器，如记事本（推荐用于本教程）、TextPad。
Netbeans - 它是一个开源且免费的 Java IDE，可以从 www.netbeans.org/index.html 下载。
Eclipse − 它也是一个由 eclipse 开源社区开发的 Java 集成开发环境，可以从 www.eclipse.org 下载。

Download Common Collections Archive

从 commons-collections4-4.1-bin.zip 下载 Apache Common Collections jar 文件的最新版本。在撰写本教程时，我们下载了 commons-collections4-4.1-bin.zip 并将其复制到 C:>Apache folder 中。

OS

Archive name

Windows

commons-collections4-4.1-bin.zip

Linux

commons-collections4-4.1-bin.tar.gz

Mac

commons-collections4-4.1-bin.tar.gz

Set Apache Common Collections Environment

将 APACHE_HOME 环境变量设置到存储在计算机上的 Apache jar 所在的基目录位置。假设我们已在各种操作系统上将 commons-collections4-4.1-bin.zip 抽取到 Apache 文件夹中，如下所示 −

OS

Archive name

Windows

将环境变量 APACHE_HOME 设置为 C:\Apache

Linux

export APACHE_HOME=/usr/local/Apache

Mac

export APACHE_HOME=/Library/Apache

Set CLASSPATH Variable

将 CLASSPATH 环境变量设置到 Common Collections jar 位置。假设你已将 commons-collections4-4.1-bin.zip 存储在各种操作系统上的 Apache 文件夹中，如下所示 −

OS

Output

Windows

将环境变量 CLASSPATH 设置到 %CLASSPATH%;%APACHE_HOME%\commons-collections4-4.1-bin.jar;.;

Linux

export CLASSPATH=$CLASSPATH:$APACHE_HOME/commons-collections4-4.1-bin.jar:.

Mac

export CLASSPATH=$CLASSPATH:$APACHE_HOME/commons-collections4-4.1-bin.jar:.

Apache Commons Collections - Bag Interface

添加了新接口来支持包。包定义了一个集合，它会计算对象在集合中出现的次数。例如，如果一个包包含 {a, a, b, c}，那么 getCount("a") 将返回 2，而 uniqueSet() 将返回唯一值。

Interface Declaration

以下是 org.apache.commons.collections4.Bag<E> 接口的声明：

public interface Bag<E>
   extends Collection<E>

Methods

包推理的方法如下：

Sr.No.	Method & Description
1	boolean add(E object) （Violation）向包中添加指定对象的副本。
2	boolean add(E object, int nCopies) 向包中添加 nCopies 份指定对象的副本。
3	boolean containsAll(Collection<?> coll) （Violation）如果包包含给定集合中的所有元素并且不改变基本数，则返回 true。
4	int getCount(Object object) 返回包中给定对象的当前出现的次数（基数）。
5	Iterator<E> iterator() 返回一个迭代器，遍历成员的整个集合，包括由于基数而产生的副本。
6	boolean remove(Object object) （违规）从包中移除给定对象的所出现的所有情况。
7	boolean remove(Object object, int nCopies) 从包中移除指定对象的 nCopies 副本。
8	boolean removeAll(Collection<?> coll) （违规）移除给定集合中表示的所有元素，并遵循基数规则。
9	boolean retainAll(Collection<?> coll) （违规）移除包中不在给定集合中的所有成员，并且遵循基数规则。
10	int size() 返回包中所有类型中项目的总数。
11	Set<E> uniqueSet() 返回包中唯一元素的集合。

Methods Inherited

此接口继承了以下接口中的方法：

java.util.Collectio.

Example of Bag Interface

BagTester.java 的一个示例如下：

import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.bag.HashBag;

public class BagTester {
   public static void main(String[] args) {
      Bag<String> bag = new HashBag<>();
      //add "a" two times to the bag.
      bag.add("a" , 2);

      //add "b" one time to the bag.
      bag.add("b");

      //add "c" one time to the bag.
      bag.add("c");

      //add "d" three times to the bag.
      bag.add("d",3

      //get the count of "d" present in bag.
      System.out.println("d is present " + bag.getCount("d") + " times.");
      System.out.println("bag: " +bag);

      //get the set of unique values from the bag
      System.out.println("Unique Set: " +bag.uniqueSet());

      //remove 2 occurrences of "d" from the bag
      bag.remove("d",2);
      System.out.println("2 occurences of d removed from bag: " +bag);
      System.out.println("d is present " + bag.getCount("d") + " times.");
      System.out.println("bag: " +bag);
      System.out.println("Unique Set: " +bag.uniqueSet());
   }
}

Output

您将看到以下输出 −

d is present 3 times.
bag: [2:a,1:b,1:c,3:d]
Unique Set: [a, b, c, d]
2 occurences of d removed from bag: [2:a,1:b,1:c,1:d]
d is present 1 times.
bag: [2:a,1:b,1:c,1:d]
Unique Set: [a, b, c, d]

Commons Collections - BidiMap Interface

新接口被添加以支持双向 Map。使用双向 Map，可以使用值来查找键，可以使用键来查找值。

Interface Declaration

下面是对 org.apache.commons.collections4.BidiMap<K,V> 接口的声明 −

public interface BidiMap<K,V>
   extends IterableMap<K,V>

Methods

BidiMap 接口的方法如下 −

Sr.No.	Method & Description
1	K getKey(Object value) 获得当前映射到指定值的键。
2	BidiMap<V,K> inverseBidiMap() 获取此映射的视图，其中键和值被反转。
3	V put(K key, V value) 将键值对置入映射中，替换任何先前的对。
4	K removeValue(Object value) 移除当前映射到指定值（可选操作）的键值对。
5	Set<V> values() 返回此映射中包含的值的 Set 视图。

Methods Inherited

此接口继承下列接口中的方法-

org.apache.commons.collections4.Ge.
org.apache.commons.collections4.IterableGe.
org.apache.commons.collections4.Pu.
java.util.Ma.

Example of BidiMap Interface

BidiMapTester.java 的示例如下 −

import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.bidimap.TreeBidiMap;

public class BidiMapTester {
   public static void main(String[] args) {
      BidiMap>String, String< bidi = new TreeBidiMap<>();

      bidi.put("One", "1");
      bidi.put("Two", "2");
      bidi.put("Three", "3");

      System.out.println(bidi.get("One"));
      System.out.println(bidi.getKey("1"));
      System.out.println("Original Map: " + bidi);

      bidi.removeValue("1");
      System.out.println("Modified Map: " + bidi);
      BidiMap<String, String> inversedMap = bidi.inverseBidiMap();
      System.out.println("Inversed Map: " + inversedMap);
   }
}

Output

运行代码后，你将看到以下输出 −

1
One
Original Map: {One=1, Three=3, Two=2}
Modified Map: {Three=3, Two=2}
Inversed Map: {2=Two, 3=Three}

Commons Collections - MapIterator Interface

JDK Map 接口很难迭代，因为迭代必须在 EntrySet 或 KeySet 对象上进行。MapIterator 在 Map 上提供简单的迭代。以下示例对此进行了说明。

Example of MapIterator Interface

MapIteratorTester.java 的示例如下 −

import org.apache.commons.collections4.IterableMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.map.HashedMap;

public class MapIteratorTester {
   public static void main(String[] args) {
      IterableMap<String, String> map = new HashedMap<>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("4", "Four");
      map.put("5", "Five");

      MapIterator<String, String> iterator = map.mapIterator();
      while (iterator.hasNext()) {
         Object key = iterator.next();
         Object value = iterator.getValue();

         System.out.println("key: " + key);
         System.out.println("Value: " + value);

         iterator.setValue(value + "_");
      }
      System.out.println(map);
   }
}

Output

输出如下 −

key: 3
Value: Three
key: 5
Value: Five
key: 2
Value: Two
key: 4
Value: Four
key: 1
Value: One
{3=Three_, 5=Five_, 2=Two_, 4=Four_, 1=One_}

Commons Collections - OrderedMap Interface

OrderedMap 是一个新的 Map 接口，用于保留元素添加的顺序。LinkedMap 和 ListOrderedMap 是两个可用的实现。此接口支持 Map 的迭代器，并允许在 Map 中按正向或反向迭代。以下示例对此进行了说明。

Example of MapIterator Interface

OrderedMapTester.java 的示例如下 −

import org.apache.commons.collections4.OrderedMap;
import org.apache.commons.collections4.map.LinkedMap;

public class OrderedMapTester {
   public static void main(String[] args) {
      OrderedMap<String, String> map = new LinkedMap<String, String>();
      map.put("One", "1");
      map.put("Two", "2");
      map.put("Three", "3");

      System.out.println(map.firstKey());
      System.out.println(map.nextKey("One"));
      System.out.println(map.nextKey("Two"));
   }
}

Output

结果如下 −

One
Two
Three

Apache Commons Collections - Ignore Null

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Check for Not Null Elements

CollectionUtils 的 addIgnoreNull() 方法可用于确保仅将非空值添加到集合中。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.addIgnoreNull() 方法 −

public static <T> boolean addIgnoreNull(Collection<T> collection, T object)

Parameters

collection − 要添加到其中的集合，不得为 null。
object − 要添加的对象，如果为 null，则不会添加。

Return Value

如果集合发生更改，则返回 True。

Exception

NullPointerException − 如果集合为 null。

Example

以下示例显示 org.apache.commons.collections4.CollectionUtils.addIgnoreNull() 方法的用法。我们尝试添加一个 null 值和一个非 null 值示例。

import java.util.LinkedList;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      List<String> list = new LinkedList<String>();
      CollectionUtils.addIgnoreNull(list, null);
      CollectionUtils.addIgnoreNull(list, "a");

      System.out.println(list);

      if(list.contains(null)) {
         System.out.println("Null value is present");
      } else {
         System.out.println("Null value is not present");
      }
   }
}

Output

输出如下：

[a]
Null value is not present

Apache Commons Collections - Merge & Sort

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Merging two sorted lists

可使用 CollectionUtils 的 collate() 方法合并两个已排序的列表。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.collate() 方法 −

public static <O extends Comparable<? super O>> List<O>
   collate(Iterable<? extends O> a, Iterable<? extends O> b)

Parameters

a - 第一个集合，不得为 null。
b - 第二个集合，不得为 null。

Return Value

一个新的已排序列表，包含集合 a 和 b 的元素。

Exception

NullPointerException − 如果任意一个集合为 null。

Example

以下示例显示 org.apache.commons.collections4.CollectionUtils.collate() 方法的用法。我们将合并两个已排序列表，然后打印已合并且已排序的列表。

import java.util.Arrays;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester { 8. Apache Commons Collections — Merge & Sort
   public static void main(String[] args) {
      List<String> sortedList1 = Arrays.asList("A","C","E");
      List<String> sortedList2 = Arrays.asList("B","D","F");
      List<String> mergedList = CollectionUtils.collate(sortedList1, sortedList2);
      System.out.println(mergedList);
   }
}

Output

输出如下 −

[A, B, C, D, E, F]

Commons Collections - Transforming Objects

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Transforming a list

可以使用 CollectionUtils 的 collect() 方法转换一种类型对象的列表为不同类型对象的列表。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.collect() 方法−

public static <I,O> Collection<O> collect(Iterable<I> inputCollection, Transformer<? super I,? extends O> transformer)

Parameters

inputCollection − 获取输入的集合，不能为空。
Transformer − 要使用的转换器，可以是 null。

Return Value

转换后的结果（新列表）。

Exception

NullPointerException − 如果输入集合为 null。

Example

以下示例展示了 org.apache.commons.collections4.CollectionUtils.collect() 方法的用法。我们将通过从 String 解析整数值，将字符串列表转换为整数列表。

import java.util.Arrays;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Transformer;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      List<String> stringList = Arrays.asList("1","2","3");
      List<Integer> integerList = (List<Integer>) CollectionUtils.collect(stringList,
         new Transformer<String, Integer>() {

         @Override
         public Integer transform(String input) {
            return Integer.parseInt(input);
         }
      });
      System.out.println(integerList);
   }
}

Output

当您使用代码时，您将获得以下代码 −

[1, 2, 3]

Commons Collections - Filtering Objects

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

filter() method

可使用 CollectionUtils 的 filter() 方法，过滤列表以删除不满足由传递的谓词提供的条件的对象。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.filter() 方法 −

public static <T> boolean filter(Iterable<T> collection,
   Predicate<? super T> predicate)

Parameters

collection − 从中获取输入的集合，不得为 null。
predicate − 用作过滤器的谓词，可以为 null。

Return Value

如果此次调用修改了集合，则返回 True，否则返回 False。

Example

以下示例显示 org.apache.commons.collections4.CollectionUtils.filter() 方法的用法。我们将过滤一个整数列表，以仅获取偶数。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      List<Integer> integerList = new ArrayList<Integer>();
      integerList.addAll(Arrays.asList(1,2,3,4,5,6,7,8));
      System.out.println("Original List: " + integerList);
      CollectionUtils.filter(integerList, new Predicate<Integer>() {
         @Override
         public boolean evaluate(Integer input) {
            if(input.intValue() % 2 == 0) {
               return true;
            }
            return false;
         }
      });
      System.out.println("Filtered List (Even numbers): " + integerList);
   }
}

Output

它将产生以下结果 −

Original List: [1, 2, 3, 4, 5, 6, 7, 8]
Filtered List (Even numbers): [2, 4, 6, 8]

filterInverse() method

可使用 CollectionUtils 的 filterInverse() 方法，过滤列表以删除满足由传递的谓词提供的条件的对象。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.filterInverse() 方法 −

public static <T> boolean filterInverse(Iterable<T> collection, Predicate<? super T> predicate)

Parameters

collection − 从中获取输入的集合，不得为 null。
predicate − 用作过滤器的谓词，可以为 null。

Return Value

如果此次调用修改了集合，则返回 True，否则返回 False。

Example

以下示例显示 org.apache.commons.collections4.CollectionUtils.filterInverse() 方法的用法。我们将过滤一个整数列表，以仅获取奇数。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      List<Integer> integerList = new ArrayList<Integer>();
      integerList.addAll(Arrays.asList(1,2,3,4,5,6,7,8));
      System.out.println("Original List: " + integerList);
      CollectionUtils.filterInverse(integerList, new Predicate<Integer>() {
         @Override
         public boolean evaluate(Integer input) {
            if(input.intValue() % 2 == 0) {
               return true;
            }
            return false;
         }
      });
      System.out.println("Filtered List (Odd numbers): " + integerList);
   }
}

Output

结果如下所述 −

Original List: [1, 2, 3, 4, 5, 6, 7, 8]
Filtered List (Odd numbers): [1, 3, 5, 7]

Commons Collections - Safe Empty Checks

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Checking non-empty list

CollectionUtils 的 isNotEmpty() 方法可用于检查一个列表是否不为空，而无需担心列表为 null。因此，在检查列表大小之前不必到处放置 null 检查。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.isNotEmpty() 方法 -

public static boolean isNotEmpty(Collection<?> coll)

Parameters

coll - 要检查的集合，可以为 null。

Return Value

如果非 null 且非空，则为 true。

Example

以下示例显示了 org.apache.commons.collections4.CollectionUtils.isNotEmpty() 方法的用法。我们将检查一个列表是否为空。

import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      List<String> list = getList();
      System.out.println("Non-Empty List Check: " + checkNotEmpty1(list));
      System.out.println("Non-Empty List Check: " + checkNotEmpty1(list));
   }
   static List<String> getList() {
      return null;
   }
   static boolean checkNotEmpty1(List<String> list) {
      return !(list == null || list.isEmpty());
   }
   static boolean checkNotEmpty2(List<String> list) {
      return CollectionUtils.isNotEmpty(list);
   }
}

Output

输出如下 −

Non-Empty List Check: false
Non-Empty List Check: false

Checking empty list

CollectionUtils 的 isEmpty() 方法可用于检查一个列表是否为空，而无需担心列表为 null。因此，在检查列表大小之前不必到处放置 null 检查。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.isEmpty() 方法 -

public static boolean isEmpty(Collection<?> coll)

Parameters

coll - 要检查的集合，可以为 null。

Return Value

如果为空或为 null 则为 true。

Example

以下示例显示了 org.apache.commons.collections4.CollectionUtils.isEmpty() 方法的用法。我们将检查一个列表是否为空。

import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      List<String> list = getList();
      System.out.println("Empty List Check: " + checkEmpty1(list));
      System.out.println("Empty List Check: " + checkEmpty1(list));
   }
   static List<String> getList() {
      return null;
   }
   static boolean checkEmpty1(List<String> list) {
      return (list == null || list.isEmpty());
   }
   static boolean checkEmpty2(List<String> list) {
      return CollectionUtils.isEmpty(list);
   }
}

Output

以下是代码的输出 −

Empty List Check: true
Empty List Check: true

Apache Commons Collections - Inclusion

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Checking sublist

CollectionUtils 的 isSubCollection() 方法可用于检查集合是否包含给定的集合。

Declaration

以下是声明：

org.apache.commons.collections4.CollectionUtils.isSubCollection() 方法 −

public static boolean isSubCollection(Collection<?> a, Collection<?> b)

Parameters

a − 第一个（子）集合，不可为 null。
b − 第二个（超级）集合，不可为 null。

Return Value

当且仅当 a 是 b 的子集合时为 True。

Example

以下示例展示了 org.apache.commons.collections4.CollectionUtils.isSubCollection() 方法的用法。我们将检查一个列表是否是另一个列表的一部分。

import java.util.Arrays;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      //checking inclusion
      List<String> list1 = Arrays.asList("A","A","A","C","B","B");
      List<String> list2 = Arrays.asList("A","A","B","B");
      System.out.println("List 1: " + list1);
      System.out.println("List 2: " + list2);
      System.out.println("Is List 2 contained in List 1: " + CollectionUtils.isSubCollection(list2, list1));
   }
}

Output

您将收到以下输出 −

List 1: [A, A, A, C, B, B]
List 2: [A, A, B, B]
Is List 2 contained in List 1: true

Apache Commons Collections - Intersection

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Checking intersection

CollectionUtils 的 intersection() 方法可用于获取两个集合之间的公共对象（交集）。

Declaration

以下是 org.apache.commons.collections4.CollectionUtils.intersection() 方法的声明 -

public static <O> Collection<O> intersection(Iterable<? extends O> a, Iterable<? extends O> b)

Parameters

a − 第一个（子）集合，不可为 null。
b − 第二个（超级）集合，不可为 null。

Return Value

两个集合的交集。

Example

以下示例展示了 org.apache.commons.collections4.CollectionUtils.intersection() 方法的用法。我们将获取两个列表的交集。

import java.util.Arrays;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      //checking inclusion
      List<String> list1 = Arrays.asList("A","A","A","C","B","B");
      List<String> list2 = Arrays.asList("A","A","B","B");
      System.out.println("List 1: " + list1);
      System.out.println("List 2: " + list2);
      System.out.println("Commons Objects of List 1 and List 2: " + CollectionUtils.intersection(list1, list2));
   }
}

Output

运行代码后，你将看到以下输出 −

List 1: [A, A, A, C, B, B]
List 2: [A, A, B, B]
Commons Objects of List 1 and List 2: [A, A, B, B]

Apache Commons Collections - Subtraction

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Checking Substraction

CollectionUtils 的 subtract() 方法可用于获取新集合，方法是从其他集合中减去一个集合的对象。

Declaration

以下是 org.apache.commons.collections4.CollectionUtils.subtract() 方法的声明：

public static <O> Collection<O> subtract(Iterable<? extends O> a, Iterable<? extends O> b)

Parameters

a - 要从其减去的集合，不得为 null。
b - 要减去的集合，不得为 null。

Return Value

一个包含结果的新集合。

Example

以下示例展示了 org.apache.commons.collections4.CollectionUtils.subtract() 方法的用法。我们将得到两个列表相减的结果。

import java.util.Arrays;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      //checking inclusion
      List<String> list1 = Arrays.asList("A","A","A","C","B","B");
      List<String> list2 = Arrays.asList("A","A","B","B");

      System.out.println("List 1: " + list1);
      System.out.println("List 2: " + list2);
      System.out.println("List 1 - List 2: "+ CollectionUtils.subtract(list1, list2));
   }
}

Output

执行以上代码时，应该看到以下输出 −

List 1: [A, A, A, C, B, B]
List 2: [A, A, B, B]
List 1 - List 2: [A, C]

Apache Commons Collections - Union

Apache Commons Collections 库的 CollectionUtils 类提供各种实用方法，用于涵盖广泛使用场景的常见操作。它有助于避免编写样板代码。在 jdk 8 之前，该库非常有用，因为 Java 8 的 Stream API 中现在提供了类似的功能。

Checking union

CollectionUtils 的 union() 方法可用于获取两个集合的并集。

Declaration

以下是 org.apache.commons.collections4.CollectionUtils.union() 方法的声明 -

public static <O> Collection<O> union(Iterable<? extends O> a, Iterable<? extends O> b)

Parameters

a - 第一个集合，不得为 null。
b - 第二个集合，不得为 null。

Return Value

两个集合的并集。

Example

以下示例显示了 org.apache.commons.collections4.CollectionUtils.union() 方法的用法。我们将获得两个列表的并集。

import java.util.Arrays;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;

public class CollectionUtilsTester {
   public static void main(String[] args) {
      //checking inclusion
      List<String> list1 = Arrays.asList("A","A","A","C","B","B");
      List<String> list2 = Arrays.asList("A","A","B","B");

      System.out.println("List 1: " + list1);
      System.out.println("List 2: " + list2);
      System.out.println("Union of List 1 and List 2: "+ CollectionUtils.union(list1, list2));
   }
}

Output

生成以下输出：

List 1: [A, A, A, C, B, B]
List 2: [A, A, B, B]
Union of List 1 and List 2: [A, A, A, B, B, C]