JAVA面试题分享五百零四：Guava集合工具

目录

关于Guava的集合工具

Guava类库的集合工具盘点

Guava的集合工具如何使用

Collections2

Iterables

Lists

Maps

Sets

Iterators

---

关于Guava的集合工具

Guava类库提供了丰富而强大的集合工具，包括不可变集合、新集合类型、集合工具类等，这些工具提供了各种实用的方法来处理集合中的元素、进行集合运算、过滤数据等，可以使得在Java中处理集合变得更加简单、高效，能够帮助开发人员更好地管理和操作集合数据。

Guava类库的集合工具盘点

1. Collections2：对Collection对象进行操作的工具方法，Collection 接口是 Java 集合框架中的一个核心接口。

2. Iterables：对Iterable对象进行操作的工具方法，Iterable 接口是 Java 中用来表示集合的接口之一。

3. Lists：对List对象进行操作的工具方法。

4. Maps：对Map对象进行操作的工具方法。

5. Sets：对Set对象进行操作的工具方法。

6. Iterators：对Iterator对象进行操作的工具方法。

7. ImmutableList：不可变列表。

8. ImmutableSet：不可变集合。

9. ImmutableMap：不可变映射表。

10. Multiset：可重复元素的集合。

11. Multimap：一对多映射关系的数据结构。

12. BiMap：双向映射的数据结构。

13. Table：二维表格的数据结构。

14. RangeSet：连续区间的数据结构。

15. Ordering：排序器，用于对集合进行排序。

16. Forwarding*：各种Forwarding类，用于扩展和包装其他集合类。

17. ClassToInstanceMap：将类与其实例关联起来的数据结构。

18. com.google.common.reflect.TypeToken：处理泛型类型擦除的工具类。

19. EvictingQueue：有限容量的队列，当超过容量限制时自动移除最老的元素。

20. ImmutableRangeSet：不可变的RangeSet，用于表示一段连续的数值范围。

21. RangeMap：将不相交的、不可数的连续区间映射到一个非空的值域的数据结构。

Guava的集合工具如何使用

在这里，让我们一起探讨一下Guava类库中常用的集合工具，深入了解它们的功能特点以及如何灵活运用这些工具来处理集合数据，帮助你更好地理解和利用这些强大的工具，从而提高代码的可维护性和性能。通过对Guava集合工具的全面认识，相信您能够更加高效地处理各种集合操作，为自己的项目带来更多便利与价值。

maven依赖

目前maven中央仓库的最新版本是32.1.3-jre，本篇文章的所有示例也是基于这个版本：

<dependency>    <groupId>com.google.guava</groupId>    <artifactId>guava</artifactId>    <version>32.1.3-jre</version></dependency>

Collections2

Collections2是 Guava 提供的一个工具类，其中包含了一些核心方法用于处理集合。以下是其中几个核心方法的功能作用和详细使用示例：

• filter(Collection<E> unfiltered, Predicate<? supter E> predicate)：根据给定的条件过滤集合中的元素。

@Testpublic void test(){    // 创建一个集合    Collection<String> names = Lists.newArrayList("Alice", "Bob", "Charlie", "David");    // 定义过滤条件    Predicate<String> predicate= item->item.length()>4;    // 过滤集合    Collection<String> longNames = Collections2.filter(names, predicate);    System.out.println(longNames);  // 输出结果为 ["Alice", "Charlie", "David"]}

• transform(Collection fromCollection, Function function)：对集合中的每个元素执行指定的转换操作。

@Testpublic void test2(){    // 创建一个集合    Collection<String> names = Lists.newArrayList("Alice", "Bob", "Charlie", "David");    // 定义转换函数    Function<String, String> toUpperCase = item->item.toUpperCase();    // 执行转换操作    Collection<String> transformed = Collections2.transform(names, toUpperCase);    System.out.println(transformed);  // 输出结果为 [ALICE, BOB, CHARLIE, DAVID]}

• orderedPermutations(Iterable iterable) 方法的功能是生成给定集合的所有有序排列，并将它们作为新的集合返回。

@Testpublic void test3() {    // 创建一个集合    List<Integer> numbers = Lists.newArrayList(1, 2, 3);    // 生成有序排列    Collection<List<Integer>> permutations = Collections2.orderedPermutations(numbers);    // 输出每个排列    for (List<Integer> permutation : permutations) {        System.out.println(permutation);    }}

• orderedPermutations(Iterable,Comparator) 方法的功能与 Collections2.orderedPermutations() 方法类似，不同之处在于该方法允许我们指定一个比较器（Comparator），用于自定义排列顺序。

@Testpublic void test4(){    // 创建一个集合    List<String> words = Lists.newArrayList("apple", "banana", "cherry");    // 定义一个比较器，用于按照字符串长度升序排列    Comparator<String> lengthComparator =(v1,v2)->Integer.compare(v1.length(),v2.length());    // 生成有序排列    Collection<List<String>> permutations = Collections2.orderedPermutations(words, lengthComparator);    // 输出每个排列    for (List<String> permutation : permutations) {        System.out.println(permutation);    }}

• permutations(Collection) 方法的功能是生成给定集合的所有排列，并将它们作为新的集合返回。

@Testpublic void test5(){    // 创建一个集合    List<Integer> numbers = Lists.newArrayList(1, 2, 3);    // 生成排列    Collection<List<Integer>> permutations = Collections2.permutations(numbers);    // 输出每个排列    for (List<Integer> permutation : permutations) {        System.out.println(permutation);    }}

Iterables

Iterables 类是 Google Guava 库中的一个工具类，提供了对 Java 集合进行操作和处理的便捷方法。该类中的方法可以直接作用于 Iterable 接口实现的集合对象上，包括 List、Set、Queue 等，提供了非常方便的集合操作功能。

• concat(Iterable... inputs)：将多个 Iterable 连接成一个 Iterable，并返回结果。

@Testpublic void test() {    Iterable<String> first = Arrays.asList("apple", "banana");    Iterable<String> second = Arrays.asList("cherry", "date");    Iterable<String> result = Iterables.concat(first, second);    result.forEach(System.out::println);}

• filter(Iterable unfiltered, Predicate predicate)：使用指定的条件过滤集合中的元素，并返回符合条件的元素组成的 Iterable。

@Testpublic void test2() {    Iterable<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);    Iterable<Integer> evenNumbers = Iterables.filter(numbers, n -> n % 2 == 0);    evenNumbers.forEach(System.out::println);}

• transform(Iterable fromIterable, Function function)：对集合中的每个元素执行指定的转换操作，并返回转换后的结果组成的 Iterable。

@Testpublic void test3() {    Iterable<String> words = Arrays.asList("apple", "banana", "cherry");    Iterable<Integer> wordLengths = Iterables.transform(words, String::length);    wordLengths.forEach(System.out::println);}

• partition(Iterable iterable, int size)：将原始集合分割成固定大小的子集合，并返回一个包含这些子集合的 Iterable。

@Testpublic void test4() {    Iterable<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);    Iterable<List<Integer>> partitions = Iterables.partition(numbers, 3);    partitions.forEach(System.out::println);}

• removeIf(Iterable removeFrom, Predicate predicate)：作用是遍历集合中的每个元素，如果该元素满足 predicate 指定的条件，则将其从集合中删除。如果集合中有任何元素被删除，则返回 true，否则返回false。

@Testpublic void test5() {    List<Integer> numbers = new ArrayList<>();    numbers.add(1);    numbers.add(2);    numbers.add(3);    numbers.add(4);    Predicate<Integer> predicate = item -> item % 2 == 0;    boolean b = Iterables.removeIf(numbers, predicate);    System.out.println(b);    numbers.forEach(System.out::println);}

• removeAll(Iterable removeFrom, Collection elementsToRemove)：作用是遍历 removeFrom 集合中的每个元素，并将其与 elementsToRemove 集合中的元素进行比较。如果 elementsToRemove 包含了某个元素，则将该元素从 removeFrom 集合中移除。如果 removeFrom 集合中有任何元素被移除，则返回 true，否则返回 false。

@Testpublic void test6() {    List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));    List<Integer> list2 = new ArrayList<>(Arrays.asList(2, 4, 6));    // 从 list1 中移除 list2 中包含的元素    boolean removed = Iterables.removeAll(list1, list2);    // 输出结果    System.out.println("Removed: " + removed);    list1.forEach(System.out::println);}

• retainAll(Iterable removeFrom, Collection elementsToRetain) ：作用是遍历 removeFrom 集合中的每个元素，并将其与 elementsToRetain 集合中的元素进行比较。如果 elementsToRetain 包含了某个元素，则将该元素保留在 removeFrom 集合中，否则将其移除。如果 removeFrom 集合中有任何元素被移除，则返回 true，否则返回 false。

@Testpublic void test7() {    List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));    List<Integer> list2 = new ArrayList<>(Arrays.asList(2, 4, 6));    // 从 list1 中移除 list2 中包含的元素    boolean retained = Iterables.retainAll(list1, list2);    // 输出结果    System.out.println("Removed: " + retained);    list1.forEach(System.out::println);}

Lists

collect.Lists 是 Google Guava 库中的一个类，它提供了一些用于操作和创建 List 集合的实用方法。

• newArrayList()：创建一个新的可变长的 ArrayList 实例。

@Testpublic void test() {    List<String> list = Lists.newArrayList();

}

• newArrayList(E... elements)：根据传入的元素创建一个新的 ArrayList 实例。

@Testpublic void test2() {    List<Integer> list = Lists.newArrayList(1, 2, 3);    list.forEach(System.out::println);}

• newLinkedList()：创建一个新的 LinkedList 实例。

@Testpublic void test3() {    List<Integer> list = Lists.newLinkedList();    List<Integer> list2 = Arrays.asList(2, 5, 8);    List<Integer> linkedList = Lists.newLinkedList(list2);    linkedList.forEach(System.out::println);}

• reverse(List list)：将给定列表中的元素顺序反转。

@Testpublic void test4() {    List<Integer> list = Lists.newArrayList(1, 2, 3);    list = Lists.reverse(list);    list.forEach(System.out::println);// [3, 2, 1]}

• partition(Listlist, int size)：将给定列表按照指定大小分割成多个子列表。

@Testpublic void test5() {    List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);    List<List<Integer>> partitions = Lists.partition(list, 2);// [[1, 2], [3, 4], [5]]    partitions.forEach(System.out::println);}

• transform(List fromList, Function function)：将给定列表中的元素通过指定的函数进行转换。

@Testpublic void test6() {    List<String> list = Lists.newArrayList("apple", "banana", "orange");    List<Integer> lengths = Lists.transform(list, String::length);    lengths.forEach(System.out::println);// [5, 6, 6]}

Maps

Maps 是 Guava 类库中的一个工具类，提供了一些操作和处理 Map 集合的方法。

• newHashMap()：创建一个新的 HashMap 实例。

@Testpublic void test() {    Map<String, Integer> map = Maps.newHashMap();}

• newHashMapWithExpectedSize(int expectedSize)：该方法用于创建一个具有指定初始容量的 HashMap 实例，可以避免在后续插入大量元素时发生重新分配内存的操作，提高性能。

@Testpublic void test2() {    Map<String, Integer> map = Maps.newHashMapWithExpectedSize(10);}

• newConcurrentMap()：创建一个新的 ConcurrentHashMap 实例。

@Testpublic void test3() {    ConcurrentMap<String, Integer> map = Maps.newConcurrentMap();}

• uniqueIndex(Iterable iterable, Function keyFunction)：将给定的可迭代对象转换为 Map，使用指定的函数作为键。

@Testpublic void test4() {    List<Student> studentList = Lists.newArrayList(            new Student(1, "Alice"),            new Student(2, "Bob"),            new Student(3, "Charlie")    );    Map<Integer, Student> studentMap = Maps.uniqueIndex(studentList, new Function<Student, Integer>() {        @Override        public Integer apply(Student student) {            return student.getStudentId();        }    });    System.out.println(studentMap);}

• toMap(Iterable iterable, Function keyFunction, Function valueFunction)：将给定的可迭代对象转换为 Map。

@Testpublic void test5() {    List<String> list = Lists.newArrayList("apple", "banana", "orange");    Map<String, Integer> map = Maps.toMap(list, String::length);// { "apple" -> 5, "banana" -> 6, "orange" -> 6 }    System.out.println(map);}

• transformValues(Map fromMap, Function function)：将给定 Map 中所有值通过指定的函数进行转换。

@Testpublic void test6(){    Map<String, String> originalMap = Maps.newHashMap();    originalMap.put("key1", "zhangsan");    originalMap.put("key2", "lisi");    Map<String, String> transformedMap = Maps.transformValues(originalMap, item->item.toUpperCase());// {key1=ZHANGSAN, key2=LISI}    System.out.println(transformedMap);}

• filterEntries(Map unfiltered, Predicate> entryPredicate)：该方法用于过滤一个 Map 集合中的键值对，返回一个新的 Map 集合，它包含原始 Map 集合中满足条件的键值对。

@Testpublic void test7(){    // 创建一个原始的 Map 对象    Map<String, Integer> map = new HashMap<>();    map.put("A", 10);    map.put("B", 20);    map.put("C", 30);    map.put("D", 40);    // 使用 Predicate 过滤条件    Predicate<Map.Entry<String, Integer>> filterCondition = entry -> entry.getValue() > 25;    // 调用 filterEntries 方法过滤 Map    Map<String, Integer> filteredMap = Maps.filterEntries(map, filterCondition);    // 打印过滤后的结果    System.out.println("Filtered Map:");    for (Map.Entry<String, Integer> entry : filteredMap.entrySet()) {        System.out.println(entry.getKey() + ": " + entry.getValue());    }}

• toMap(Iterable iterable, Function keyFunction, Function valueFunction)：将给定的可迭代对象转换为 Map。

@Testpublic void test8() {    // 创建一个 Iterable    List<String> list = Arrays.asList("apple", "banana", "cherry");    // 使用 Function 进行转换    Function<String, Integer> lengthFunction = String::length;    // 调用 toMap 方法转换为 Map    Map<String, Integer> lengthMap = Maps.toMap(list, lengthFunction);    // 打印转换后的结果    System.out.println("Length Map: " + lengthMap);}

• Maps#difference(Map, Map)：该方法用于返回两个 Map 集合之间的差异，即返回一个 Map 集合，这个集合包含了第一个 Map 中所有的键值对，但是不包含第二个 Map 中的键值对。如果第二个 Map 中存在第一个 Map 不包含的键，则在返回的 Map 集合中会包含这些键。如果两个 Map 集合相等，则返回的 Map 集合为空。

@Testpublic void test9() {    // 创建两个 Map 对象    Map<String, Integer> map1 = new HashMap<>();    map1.put("A", 10);    map1.put("B", 20);    map1.put("C", 30);    Map<String, Integer> map2 = new HashMap<>();    map2.put("B", 20);    map2.put("C", 35);    map2.put("D", 40);    // 调用 difference 方法比较差异    MapDifference<String, Integer> difference = Maps.difference(map1, map2);    // 打印差异的详细信息    System.out.println("Entries only on left: " + difference.entriesOnlyOnLeft());    System.out.println("Entries only on right: " + difference.entriesOnlyOnRight());    System.out.println("Entries in common: " + difference.entriesInCommon());    System.out.println("Entries differing: " + difference.entriesDiffering());}

• Maps#filterKeys(Map , Predicate)：该方法用于过滤一个 Map 集合中的键，返回一个新的 Map 集合，它包含原始 Map 集合中所有的键值对，但是只有满足条件的键值对会被保留。

@Testpublic void test10() {    // 创建一个 Map 对象    Map<String, Integer> originalMap = new HashMap<>();    originalMap.put("apple", 10);    originalMap.put("banana", 20);    originalMap.put("orange", 30);    // 定义 Predicate 对象，用于过滤键    Predicate<String> keyFilter = key -> key.startsWith("a");    // 使用 filterKeys 方法过滤键    Map<String, Integer> filteredMap = Maps.filterKeys(originalMap, keyFilter);    // 打印过滤后的 Map    System.out.println("Original Map: " + originalMap);    System.out.println("Filtered Map: " + filteredMap);}

• Maps#filterValues(Map , Predicate)：该方法用于过滤一个 Map 集合中的值，返回一个新的 Map 集合，它包含原始 Map 集合中所有的键值对，但是只有满足条件的键值对会被保留。

@Testpublic void test11() {    // 创建一个示例 Map    Map<String, Integer> map = Maps.newHashMap();    map.put("apple", 10);    map.put("banana", 20);    map.put("cherry", 30);    map.put("date", 40);    // 定义一个 Predicate，筛选值大于等于30的键值对    Predicate<Integer> predicate = item -> item > 30;    // 使用 filterValues 方法过滤值    Map<String, Integer> filteredMap = Maps.filterValues(map, predicate);    // 打印过滤后的结果    System.out.println(filteredMap);}

Sets

Sets 类是 Guava 提供的一个工具类，用于操作和处理集合（Set）

• newHashSet()：创建一个新的 HashSet 实例，并返回该实例。可以用于快速创建一个 HashSet 集合。

@Testpublic void test() {    Set<String> set = Sets.newHashSet("apple", "banana", "orange");    System.out.println(set); // 输出: [apple, banana, orange]}

• newLinkedHashSet()：创建一个新的 LinkedHashSet 实例，并返回该实例。可以用于快速创建一个有序的 LinkedHashSet 集合。

@Testpublic void test2(){    Iterable<String> iterable= Arrays.asList("apple", "banana", "orange");    Set<String> set = Sets.newLinkedHashSet(iterable);    System.out.println(set); // 输出: [apple, banana, orange]}

• newTreeSet()：创建一个新的 TreeSet 实例，并返回该实例。可以用于快速创建一个有序的 TreeSet 集合。

@Testpublic void test3(){    Set<String> set = Sets.newTreeSet();    set.add("apple");    set.add("banana");    set.add("orange");    System.out.println(set); // 输出: [apple, banana, orange]}

• newHashSet(Iterable)：从 Iterable 对象中创建一个新的 HashSet 实例，并返回该实例。可以用于从其他集合或迭代器中创建 HashSet 集合。

@Testpublic void test4(){    Iterable<String> iterable = Arrays.asList("apple", "banana", "orange");    Set<String> set = Sets.newHashSet(iterable);    System.out.println(set); // 输出: [apple, banana, orange]}

• powerSet(Set)：返回一个给定集合的所有子集（包括空集和原集合本身）的集合。

@Testpublic void test5(){    Set<Integer> set = Sets.newHashSet(1, 2, 3);    Set<Set<Integer>> powerSet = Sets.powerSet(set);    System.out.println(powerSet); // 输出: [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]}

• cartesianProduct(Set...)：返回给定多个集合的笛卡尔积的集合。

@Testpublic void test6(){    Set<Integer> set1 = Sets.newHashSet(1, 2);    Set<String> set2 = Sets.newHashSet("A", "B");    Set<List<Object>> cartesianProduct = Sets.cartesianProduct(set1, set2);    System.out.println(cartesianProduct); // 输出: [[1, A], [1, B], [2, A], [2, B]]}

Iterators

Iterators 类是 Guava 提供的一个工具类，用于操作和处理迭代器（Iterator）。

• concat(Iterator...)：将多个迭代器合并成一个，返回一个新的迭代器。

@Testpublic void test() {    Iterator<Integer> iterator1 = Arrays.asList(1, 2).iterator();    Iterator<Integer> iterator2 = Arrays.asList(3, 4).iterator();    Iterator<Integer> concatenatedIterator = Iterators.concat(iterator1, iterator2);    while (concatenatedIterator.hasNext()) {        System.out.print(concatenatedIterator.next() + " "); // 输出: 1 2 3 4    }}

• cycle(Iterable)：创建一个可以无限循环遍历给定 Iterable 对象的迭代器。

@Testpublic void test2() {    Iterator<Integer> cycleIterator = Iterators.cycle(Arrays.asList(1, 2));    for (int i = 0; i < 5; i++) {        System.out.print(cycleIterator.next() + " "); // 输出: 1 2 1 2 1    }}

• filter(Iterator, Predicate)：返回一个只包含满足给定条件的元素的迭代器

@Testpublic void test3() {    Iterator<Integer> iterator = Iterators.forArray(1, 2, 3, 4, 5);    Predicate<Integer> isEven = item -> item % 2 == 0;    Iterator<Integer> filteredIterator = Iterators.filter(iterator, isEven);    while (filteredIterator.hasNext()) {        System.out.print(filteredIterator.next() + " "); // 输出: 2 4    }}

• limit(Iterator, int)：返回一个最多包含给定数量元素的迭代器。

@Testpublic void test4() {    Iterator<Integer> iterator = Iterators.forArray(1, 2, 3, 4, 5);    Iterator<Integer> limitedIterator = Iterators.limit(iterator, 3);    while (limitedIterator.hasNext()) {        System.out.print(limitedIterator.next() + " "); // 输出: 1 2 3    }}

• transform(Iterator, Function)：返回一个将迭代器中的每个元素都经过给定函数处理后得到的结果的迭代器。

@Testpublic void test5() {    Iterator<String> iterator = Iterators.forArray("apple", "banana", "orange");    Function<String, Integer> lengthFunction = item -> item.length();    Iterator<Integer> transformedIterator = Iterators.transform(iterator, lengthFunction);    while (transformedIterator.hasNext()) {        System.out.print(transformedIterator.next() + " "); // 输出: 5 6 6    }}