Guava中的集合

文章引用：http://ifeve.com/google-guava-immutablecollections/

一、 不可变集合

为什么要使用不可变集合

• 优点：

  1. 当对象被不可信的库调用时，不可变形式是安全的；
  2. 不可变对象被多个线程调用时，不存在竞态条件问题；
  3. 不可变集合不需要考虑变化，因此可以节省时间和空间。所有不可变的集合都比它们的可变形式有更好的内存利用率；
  4. 不可变对象因为有固定不变，可以作为常量来安全使用。

• 不可变集合的几种创建方式：
  copyOf方法

List<String> list = Arrays.asList("a", "b", "c");
ImmutableSet<String> strings = ImmutableSet.copyOf(list);

of方法

ImmutableSet<String> of = ImmutableSet.of("a", "b", "c", "d", "e");

Builder工具

ImmutableSet<String> set = ImmutableSet.<String>builder().add("a").add("b").add("c").build();

二、 新的集合类型

可变集合与不可变集合（来自并发编程网）.png

1.Multiset

Multiset<String> multiset = HashMultiset.create();
multiset.add("a");
multiset.add("a");
multiset.add("b");
int a = multiset.count("a");
System.out.println("包含重复元素的个数  " + multiset.size());
System.out.println("不包含重复元素的个数 " + multiset.elementSet().size());
// 可以统计每个元素出现的个数
System.out.println("元素a出现的次数 " + a);
----------------------------------
out:
    包含重复元素的个数  3
    不包含重复元素的个数 2
    元素a出现的次数 2

Guava 提供了多种Multiset实现

Multiset的多种实现.png

SortedMultiset<String> sortedMultiset = TreeMultiset.create();
sortedMultiset.add("a");
sortedMultiset.add("b");
sortedMultiset.add("c");
sortedMultiset.add("d");
sortedMultiset.add("e");
SortedMultiset<String> strings = sortedMultiset.subMultiset("a", BoundType.CLOSED, "e", BoundType.OPEN);
strings.forEach(System.out::print);
----------------------------------
out:
    输出：abcd

2.Multimap

        ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
        multimap.put("a", 1);
        multimap.put("a", 2);
        multimap.put("a", 3);
        multimap.put("a", 4);
        multimap.put("b", 1);
        System.out.println(multimap.size());

        //  asMap() 提供Map<K,Collection<V>>形式的视图 collections 中
        //  a->{1,2,3,4}
        //  b->{1}
        Collection<Collection<Integer>> collections = multimap.asMap().values();

        // values {1,2,3,4,1}
        Collection<Integer> values = multimap.values();

        Collection<Map.Entry<String, Integer>> entries = multimap.entries();
        entries.forEach(item -> {
            System.out.print("key--->" + item.getKey());
            System.out.println("  value--->" + item.getValue());
        });
----------------------------------
        out:
              5
              key--->a  value--->1
              key--->a  value--->2
              key--->a  value--->3
              key--->a  value--->4
              key--->b  value--->1

Multimap的各种实现

Multimap的各种实现.png

3.RangeSet

        RangeSet<Integer> rangeSet = TreeRangeSet.create();
        // 闭区间 [1,10]
        rangeSet.add(Range.closed(1, 10));
        // 左闭右开区间 [11,15) 如果左边为11 则和上边的区间为不连续区间  如果左边为10 则两个区间进行合并
        rangeSet.add(Range.closedOpen(11, 15));
        // 返回包含指定元素的区间，如果没有这样的区间则返回null
        Range<Integer> integerRange = rangeSet.rangeContaining(5);
        // 返回包含rangeSet 所有区间的最小区间
        Range<Integer> span = rangeSet.span();
        System.out.println(integerRange);
        System.out.println(span);
---------------------------------                
out:
      [1..10]
      [1..15)

还存在一个RangeMap<Integer, String> ，但是和RangeSet不同的是RangeMap不会合并相邻的映射，即便相邻的区间映射到相同的值。

4.Table

        Table<String, Integer, String> table = HashBasedTable.create();
        table.put("a", 1, "第一个值");
        table.put("a", 2, "第二个值");
        table.put("a", 3, "第三个值");
        table.put("b", 1, "第一个值");
        table.put("b", 4, "第四个值");

        Map<Integer, String> a = table.row("a");
        Map<Integer, String> b = table.row("b");
        Map<String, String> column = table.column(1);
        Set<Table.Cell<String, Integer, String>> cells = table.cellSet();
        Map<Integer, Map<String, String>> columnMap = table.columnMap();
        Collection<String> values = table.values();
        System.out.println("");

Table:output

Table的多种实现

Table的多种实现.png