Apache Commons Collections-有用的资源

Apache Commons Collections是一个Java类库，提供了许多实用的数据结构和算法。本文介绍一些常用的资源和用法。

官方文档

官方文档包含了大量的使用说明和示例代码，非常适合初学者。

官方文档地址：http://commons.apache.org/proper/commons-collections/javadocs/api-release/index.html

Apache Commons Wiki

Apache Commons Wiki包含了更多的使用示例和教程，以及源代码和开发者指南。

Apache Commons Wiki地址：https://wiki.apache.org/commons/CommonsCollections

集合类型

Apache Commons Collections提供了许多有用的集合类型，包括List、Set、Map等等。其中部分类型允许定义自定义的键值比较器。

List

PredicatedList

PredicatedList类是一个装饰器类，可以将一个List类型的对象包装为一个新的List类型的对象，新的对象只允许符合指定条件的元素。

List<String> list = new ArrayList<>();
list.add("abc");
list.add("123");
List<String> predicatedList = PredicatedList.predicatedList(list, new Predicate<String>() {
    @Override
    public boolean evaluate(String s) {
        // 只允许包含数字和小写字母
        return s.matches("[a-z0-9]+");
    }
});

Set

SetUniqueList

SetUniqueList类是一种组合了List和Set的集合类型。与同样使用链表实现的LinkedList相比，SetUniqueList具有快速的查找和去重的功能，还可以保持元素的添加顺序。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(1);
List<Integer> setUniqueList = SetUniqueList.setUniqueList(list);
// 输出 [1, 2]
System.out.println(setUniqueList.toString());

Map

MultiValueMap

MultiValueMap类是一种Key对应多个Value的Map类型。与同样使用数组实现的HashMap相比，MultiValueMap可以更方便地管理多个Value，并通过丰富的API进行操作。

MultiValueMap<String, String> map = new ArrayListValuedHashMap<>();
map.put("fruit", "apple");
map.put("fruit", "banana");
map.put("meat", "beef");
// 输出 {fruit=[apple, banana], meat=[beef]}
System.out.println(map.toString());

自定义键值比较器

有些集合类型允许自定义键值比较器，以便更好地控制元素在集合中的排序和查找等。

TransformingComparator

TransformingComparator是一种可以将集合中的元素进行转换后再进行比较的比较器类型。

Comparator<Person> nameComparator = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getName().compareTo(o2.getName());
    }
};
Comparator<Person> ageComparator = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
};
List<Person> list = new ArrayList<Person>();
list.add(new Person("Tom", 20));
list.add(new Person("Jerry", 18));
Comparator<Person> byNameIgnoreCaseComparator =
    new TransformingComparator<Person, String>(new GetInvoker<Person, String>("name", true), String.CASE_INSENSITIVE_ORDER);
Collections.sort(list, byNameIgnoreCaseComparator);
// 输出 [Jerry, Tom]
System.out.println(list.toString());

ChainedComparator

ChainedComparator是一种可以通过多个比较器将元素进行顺序排列的比较器类型。

List<Person> list = new ArrayList<Person>();
list.add(new Person("Tom", 20));
list.add(new Person("Jerry", 18));
list.add(new Person("Mike", 22));
Comparator<Person> byNameIgnoreCaseComparator =
    new TransformingComparator<Person, String>(new GetInvoker<Person, String>("name", true), String.CASE_INSENSITIVE_ORDER);
Comparator<Person> byAgeComparator = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
};
Comparator<Person> chainedComparator = ComparatorUtils.chainedComparator(
    new Comparator[]{byNameIgnoreCaseComparator, byAgeComparator});
Collections.sort(list, chainedComparator);
// 输出 [Jerry, Mike, Tom]
System.out.println(list.toString());

集合算法

除了提供常用的集合类型外，Apache Commons Collections还提供了一些有用的集合算法，如排序、归并、分组等。

排序

ComparatorChain

ComparatorChain是一种可以通过多个比较器决定元素顺序的算法类型。

List<Person> list = new ArrayList<Person>();
list.add(new Person("Tom", 20));
list.add(new Person("Jerry", 18));
list.add(new Person("Mike", 22));
Comparator<Person> byNameIgnoreCaseComparator =
    new TransformingComparator<Person, String>(new GetInvoker<Person, String>("name", true), String.CASE_INSENSITIVE_ORDER);
Comparator<Person> byAgeComparator = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
};
Comparator<Person> comparatorChain = new ComparatorChain<Person>(
    new Comparator[]{byNameIgnoreCaseComparator, byAgeComparator});
Collections.sort(list, comparatorChain);
// 输出 [Jerry, Mike, Tom]
System.out.println(list.toString());

ReverseComparator

ReverseComparator是一种可以将比较结果反转的比较器类型。

List<Person> list = new ArrayList<Person>();
list.add(new Person("Tom", 20));
list.add(new Person("Jerry", 18));
list.add(new Person("Mike", 22));
Comparator<Person> byNameIgnoreCaseComparator =
    new TransformingComparator<Person, String>(new GetInvoker<Person, String>("name", true), String.CASE_INSENSITIVE_ORDER);
Comparator<Person> byAgeComparator = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
};
Comparator<Person> comparatorChain = new ComparatorChain<Person>(
    new Comparator[]{byAgeComparator, new ReverseComparator<Person>(byNameIgnoreCaseComparator)});
Collections.sort(list, comparatorChain);
// 输出 [Mike, Tom, Jerry]
System.out.println(list.toString());

归并

CollectionUtils.union

CollectionUtils.union方法可以将两个List对象进行归并，并去重。

List<String> list1 = Arrays.asList("abc", "123");
List<String> list2 = Arrays.asList("xyz", "123");
List<String> result = new ArrayList<String>(CollectionUtils.union(list1, list2));
// 输出 [abc, 123, xyz]
System.out.println(result.toString());

分组

CollectionUtils.groupBy

CollectionUtils.groupBy方法可以根据指定的属性将一个List对象进行分组，并返回一个Map对象，其中Key为属性值，Value为该属性值下的元素列表。

List<Person> list = new ArrayList<Person>();
list.add(new Person("Tom", "male"));
list.add(new Person("Jerry", "male"));
list.add(new Person("Alice", "female"));
Map<String, List<Person>> resultMap =
    (Map<String, List<Person>>) CollectionUtils.groupBy(list, new BeanPropertyValueTransformer("gender"));
// 输出 {female=[Person{name='Alice', gender='female'}], male=[Person{name='Tom', gender='male'},
// Person{name='Jerry', gender='male'}]}
System.out.println(resultMap.toString());

总结

Apache Commons Collections提供了许多有用的集合类型和算法，使Java程序员能够更方便地处理集合数据。使用它可以提高程序的效率和代码质量，是Java开发不可或缺的工具之一。