Guava 集合类

柔情只为你懂 2021-10-01 12:08 367阅读 0赞

#### 不可变集合类 ####

public static final ImmutableSet<String> COLOR_NAMES = ImmutableSet.of(
            "red",
            "orange",
            "yellow",
            "green",
            "blue",
            "purple");
    
    class Foo {
        Set<Bar> bars;
        Foo(Set<Bar> bars) {
            this.bars = ImmutableSet.copyOf(bars); // defensive copy!
        }
    }

为什么要使用不可变集合  
不可变对象有很多优点，包括：

> 当对象被不可信的库调用时，不可变形式是安全的；  
> 不可变对象被多个线程调用时，不存在竞态条件问题  
> 不可变集合不需要考虑变化，因此可以节省时间和空间。所有不可变的集合都比它们的可变形式有更好的内存利用率（分析和测试细节）；  
> 不可变对象因为有固定不变，可以作为常量来安全使用。  
> 创建对象的不可变拷贝是一项很好的防御性编程技巧。Guava为所有JDK标准集合类型和Guava新集合类型都提供了简单易用的不可变版本。

JDK也提供了Collections.unmodifiableXXX方法把集合包装为不可变形式，但我们认为不够好：

笨重而且累赘：不能舒适地用在所有想做防御性拷贝的场景；  
不安全：要保证没人通过原集合的引用进行修改，返回的集合才是事实上不可变的；  
低效：包装过的集合仍然保有可变集合的开销，比如并发修改的检查、散列表的额外空间，等等。  
如果你没有修改某个集合的需求，或者希望某个集合保持不变时，把它防御性地拷贝到不可变集合是个很好的实践。

重要提示：所有Guava不可变集合的实现都不接受null值。我们对Google内部的代码库做过详细研究，发现只有5%的情况需要在集合中允许null元素，剩下的95%场景都是遇到null值就快速失败。如果你需要在不可变集合中使用null，请使用JDK中的Collections.unmodifiableXXX方法。更多细节建议请参考“使用和避免null”。

怎么使用不可变集合  
不可变集合可以用如下多种方式创建：

1. copyOf方法，如ImmutableSet.copyOf(set);
    of方法，如ImmutableSet.of(“a”, “b”, “c”)或 ImmutableMap.of(“a”, 1, “b”, 2);
    2. Builder工具，如
    public static final ImmutableSet<Color> GOOGLE_COLORS =
            ImmutableSet.<Color>builder()
                .addAll(WEBSAFE_COLORS)
                .add(new Color(0, 191, 255))
                .build();
    此外，对有序不可变集合来说，排序是在构造集合的时候完成的，如：
    
    3. ImmutableSortedSet.of("a", "b", "c", "a", "d", "b");
    会在构造时就把元素排序为a, b, c, d。

我测试发现： of方法得到的不可变集合，如果原集合增加，它也随之增加，其他的不受影响。

比想象中更智能的copyOf

请注意，ImmutableXXX.copyOf方法会尝试在安全的时候避免做拷贝——实际的实现细节不详，但通常来说是很智能的，比如：

ImmutableSet<String> foobar = ImmutableSet.of("foo", "bar", "baz");
    thingamajig(foobar);
    
    void thingamajig(Collection<String> collection) {
        ImmutableList<String> defensiveCopy = ImmutableList.copyOf(collection);
        ...
    }

在这段代码中，ImmutableList.copyOf(foobar)会智能地直接返回foobar.asList(),它是一个ImmutableSet的常量时间复杂度的List视图。  
作为一种探索，ImmutableXXX.copyOf(ImmutableCollection)会试图对如下情况避免线性时间拷贝：

*  在常量时间内使用底层数据结构是可能的——例如，ImmutableSet.copyOf(ImmutableList)就不能在常量时间内完成。
 *  不会造成内存泄露——例如，你有个很大的不可变集合ImmutableList<String>  
    hugeList， ImmutableList.copyOf(hugeList.subList(0, 10))就会显式地拷贝，以免不必要地持有hugeList的引用。
 *  不改变语义——所以ImmutableSet.copyOf(myImmutableSortedSet)会显式地拷贝，因为和基于比较器的ImmutableSortedSet相比，ImmutableSet对hashCode()和equals有不同语义。
 *  在可能的情况下避免线性拷贝，可以最大限度地减少防御性编程风格所带来的性能开销。

asList视图

所有不可变集合都有一个asList()方法提供ImmutableList视图，来帮助你用列表形式方便地读取集合元素。例如，你可以使用sortedSet.asList().get(k)从ImmutableSortedSet中读取第k个最小元素。

asList()返回的ImmutableList通常是——并不总是——开销稳定的视图实现，而不是简单地把元素拷贝进List。也就是说，asList返回的列表视图通常比一般的列表平均性能更好，比如，在底层集合支持的情况下，它总是使用高效的contains方法。

### 新集合类型 ###

## Multiset ##

统计一个词在文档中出现了多少次，传统的做法是这样的：

Map<String, Integer> counts = new HashMap<String, Integer>();
    for (String word : words) {
        Integer count = counts.get(word);
        if (count == null) {
            counts.put(word, 1);
        } else {
            counts.put(word, count + 1);
        }
    }

这种写法很笨拙，也容易出错，并且不支持同时收集多种统计信息，如总词数。我们可以做的更好。

Guava提供了一个新集合类型 Multiset，它可以多次添加相等的元素。维基百科从数学角度这样定义Multiset：”集合\[set\]概念的延伸，它的元素可以重复出现…与集合\[set\]相同而与元组\[tuple\]相反的是，Multiset元素的顺序是无关紧要的：Multiset \{a, a, b\}和\{a, b, a\}是相等的”。——*译者注：这里所说的集合**\[set\]是数学上的概念，Multiset继承自JDK中的Collection接口，而不是Set接口，所以包含重复元素并没有违反原有的接口契约。*

可以用两种方式看待Multiset：

*  没有元素顺序限制的ArrayList<E>
 *  Map<E, Integer>，键为元素，值为计数

Guava的Multiset API也结合考虑了这两种方式：  
当把Multiset看成普通的Collection时，它表现得就像无序的ArrayList：

*  add(E)添加单个给定元素
 *  iterator()返回一个迭代器，包含Multiset的所有元素（包括重复的元素）
 *  size()返回所有元素的总个数（包括重复的元素）

当把Multiset看作Map<E, Integer>时，它也提供了符合性能期望的查询操作：

*  count(Object)返回给定元素的计数。HashMultiset.count的复杂度为O(1)，TreeMultiset.count的复杂度为O(log n)。
 *  entrySet()返回Set<Multiset.Entry<E>>，和Map的entrySet类似。
 *  elementSet()返回所有不重复元素的Set<E>，和Map的keySet()类似。
 *  所有Multiset实现的内存消耗随着不重复元素的个数线性增长。

值得注意的是，除了极少数情况，Multiset和JDK中原有的Collection接口契约完全一致——具体来说，TreeMultiset在判断元素是否相等时，与TreeSet一样用compare，而不是Object.equals。另外特别注意，Multiset.addAll(Collection)可以添加Collection中的所有元素并进行计数，这比用for循环往Map添加元素和计数方便多了。

### SortedMultiset ###

SortedMultiset 是Multiset 接口的变种，它支持高效地获取指定范围的子集。比方说，你可以用 latencies.subMultiset(0,BoundType.CLOSED, 100, BoundType.OPEN).size()来统计你的站点中延迟在100毫秒以内的访问，然后把这个值和latencies.size()相比，以获取这个延迟水平在总体访问中的比例。

TreeMultiset实现SortedMultiset接口。

## Multimap ##

每个有经验的Java程序员都在某处实现过Map<K, List<V>>或Map<K, Set<V>>，并且要忍受这个结构的笨拙。例如，Map<K, Set<V>>通常用来表示非标定有向图。Guava的 Multimap可以很容易地把一个键映射到多个值。换句话说，Multimap是把键映射到任意多个值的一般方式。

可以用两种方式思考Multimap的概念：”键-单个值映射”的集合：

a -> 1 a -> 2 a ->4 b -> 3 c -> 5

或者”键-值集合映射”的映射：

a -> \[1, 2, 4\] b -> 3 c -> 5

一般来说，Multimap接口应该用第一种方式看待，但asMap()视图返回Map<K, Collection<V>>，让你可以按另一种方式看待Multimap。重要的是，不会有任何键映射到空集合：一个键要么至少到一个值，要么根本就不在Multimap中。

很少会直接使用Multimap接口，更多时候你会用ListMultimap或SetMultimap接口，它们分别把键映射到List或Set。

### 修改Multimap ###

Multimap.get(key) 以集合形式返回键所对应的值视图，即使没有任何对应的值，也会返回空集合。ListMultimap.get(key)返回List，SetMultimap.get(key)返回Set。

对值视图集合进行的修改最终都会反映到底层的Multimap。

### Multimap的视图 ###

Multimap还支持若干强大的视图：

*  asMap为Multimap<K, V>提供Map<K,Collection<V>>形式的视图。返回的Map支持remove操作，并且会反映到底层的Multimap，但它不支持put或putAll操作。更重要的是，如果你想为Multimap中没有的键返回null，而不是一个新的、可写的空集合，你就可以使用asMap().get(key)。（你可以并且应当把asMap.get(key)返回的结果转化为适当的集合类型——如SetMultimap.asMap.get(key)的结果转为Set，ListMultimap.asMap.get(key)的结果转为List——Java类型系统不允许ListMultimap直接为asMap.get(key)返回List——*译者注：也可以用**Multimaps中的asMap静态方法帮你完成类型转换*）
 *  entries用Collection<Map.Entry<K, V>>返回Multimap中所有”键-单个值映射”——包括重复键。（对SetMultimap，返回的是Set）
 *  keySet用Set表示Multimap中所有不同的键。
 *  keys用Multiset表示Multimap中的所有键，每个键重复出现的次数等于它映射的值的个数。可以从这个Multiset中移除元素，但不能做添加操作；移除操作会反映到底层的Multimap。
 *  values()用一个”扁平”的Collection<V>包含Multimap中的所有值。这有一点类似于Iterables.concat(multimap.asMap().values())，但它直接返回了单个Collection，而不像multimap.asMap().values()那样是按键区分开的Collection。

## BiMap ##

1.双向映射

2.value唯一。 插入相同value报错，forcePut()强制插入会更改key

3.inverse()方法翻转key与value。不返回新对象，保持一种视图关联，操作会互相影响。

![5057999-c1dcd07b9999869b.png][]

## Table ##

多个索引的数据结构的，通常情况下，我们只能用这种丑陋的Map<FirstName, Map<LastName, Person>>来实现。guava的table提供更方便的实现。类似一个表的结构，并且可以切换视图。

![5057999-3bd1fa841dd13708.png][]

public void test(){
        Table<String, Integer, String> aTable = HashBasedTable.create();
        for (char a = 'A'; a <= 'C'; ++a) {
            for (Integer b = 1; b <= 3; ++b) {
                aTable.put(Character.toString(a), b, String.format("%c%d", a, b));
            }
        }
        System.out.println(aTable);
        System.out.println(aTable.rowKeySet());
        System.out.println(aTable.columnKeySet());
        System.out.println(aTable.row("A"));
        System.out.println(aTable.get("B",2));
        System.out.println(aTable.contains("A",4));
        System.out.println(aTable.columnMap());
        System.out.println(aTable.rowMap());
        System.out.println(aTable.size());
        System.out.println(aTable.remove("A",1));
        System.out.println(aTable);
    }

[5057999-c1dcd07b9999869b.png]: /images/20210811/e760e54f0ee3458099093eca45e8e9b9.png
[5057999-3bd1fa841dd13708.png]: /images/20210811/fefa46c411554858995fc300f9b62db8.png