guava总结

功能列举

可以说 Java Collections Framework 满足了我们大多数情况下使用集合的要求，但是当遇到一些特殊的情况我们的代码会比较冗长，比较容易出错。Guava Collections 可以帮助你的代码更简短精炼，更重要是它增强了代码的可读性。看看 Guava Collections 为我们做了哪些很酷的事情。

  • Immutable Collections: 还在使用 Collections.unmodifiableXXX() ？ Immutable Collections 这才是真正的不可修改的集合
  • Multiset: 看看如何把重复的元素放入一个集合
  • Multimaps: 需要在一个 key 对应多个 value 的时候 , 自己写一个实现比较繁琐 - 让 Multimaps 来帮忙
  • BiMap: java.util.Map 只能保证 key 的不重复，BiMap 保证 value 也不重复
  • MapMaker: 超级强大的 Map 构造类
  • Ordering class: 大家知道用 Comparator 作为比较器来对集合排序，但是对于多关键字排序 Ordering class 可以简化很多的代码
  • 其他特性

当然，如果没有 Guava Collections 你也可以用 Java Collections Framework 完成上面的功能。但是 Guava Collections 提供的这些 API 经过精心设计，而且还有 25000 个单元测试来保障它的质量。所以我们没必要重新发明轮子。接下来我们来详细看看 Guava Collections 的一些具体功能。

Immutable Collections: 真正的不可修改的集合

大家都用过 Collections.unmodifiableXXX() 来做一个不可修改的集合。例如你要构造存储常量的 Set，你可以这样来做 :

 Set<String> set = new HashSet<String>(Arrays.asList(new String[]{"RED", "GREEN"}));
 Set<String> unmodifiableSet = Collections.unmodifiableSet(set);

这看上去似乎不错，因为每次调 unmodifiableSet.add() 都会抛出一个 UnsupportedOperationException。感觉安全了？慢！如果有人在原来的 set 上 add 或者 remove 元素会怎么样？结果 unmodifiableSet 也是被 add 或者 remove 元素了。而且构造这样一个简单的 set 写了两句长的代码。下面看看 ImmutableSet 是怎么来做地更安全和简洁 :

 ImmutableSet<String> immutableSet = ImmutableSet.of("RED", "GREEN");

就这样一句就够了，而且试图调 add 方法的时候，它一样会抛出 UnsupportedOperationException。重要的是代码的可读性增强了不少，非常直观地展现了代码的用意。如果像之前这个代码保护一个 set 怎么做呢？你可以 :

 ImmutableSet<String> immutableSet = ImmutableSet.copyOf(set);

从构造的方式来说，ImmutableSet 集合还提供了 Builder 模式来构造一个集合 :

 Builder<String>  builder = ImmutableSet.builder();
 ImmutableSet<String> immutableSet = builder.add("RED").addAll(set).build();

在这个例子里面 Builder 不但能加入单个元素还能加入既有的集合。

除此之外，Guava Collections 还提供了各种 Immutable 集合的实现：ImmutableList，ImmutableMap，ImmutableSortedSet，ImmutableSortedMap。

Multiset: 把重复的元素放入集合

你可能会说这和 Set 接口的契约冲突，因为 Set 接口的 JavaDoc 里面规定不能放入重复元素。事实上，Multiset 并没有实现 java.util.Set 接口，它更像是一个 Bag。普通的 Set 就像这样 :[car, ship, bike]，而 Multiset 会是这样 : [car x 2, ship x 6, bike x 3]。

譬如一个 List 里面有各种字符串，然后你要统计每个字符串在 List 里面出现的次数 :

 Map<String, Integer> map = new HashMap<String, Integer>();
 for(String word : wordList){
    Integer count = map.get(word);
    map.put(word, (count == null) ? 1 : count + 1);
 }
 //count word “the”
 Integer count = map.get(“the”);

如果用 Multiset 就可以这样 :

 HashMultiset<String> multiSet = HashMultiset.create();
 multiSet.addAll(wordList);
 //count word “the”
 Integer count = multiSet.count(“the”);

这样连循环都不用了，而且 Multiset 用的方法叫 count，显然比在 Map 里面调 get 有更好的可读性。Multiset 还提供了 setCount 这样设定元素重复次数的方法，虽然你可以通过使用 Map 来实现类似的功能，但是程序的可读性比 Multiset 差了很多。

常用实现 Multiset 接口的类有：

  • HashMultiset: 元素存放于 HashMap
  • LinkedHashMultiset: 元素存放于 LinkedHashMap，即元素的排列顺序由第一次放入的顺序决定
  • TreeMultiset:元素被排序存放于TreeMap
  • EnumMultiset: 元素必须是 enum 类型
  • ImmutableMultiset: 不可修改的 Mutiset

看到这里你可能已经发现 Guava Collections 都是以 create 或是 of 这样的静态方法来构造对象。这是因为这些集合类大多有多个参数的私有构造方法，由于参数数目很多，客户代码程序员使用起来就很不方便。而且以这种方式可以返回原类型的子类型对象。另外，对于创建范型对象来讲，这种方式更加简洁。

Multimap: 在 Map 的 value 里面放多个元素

Muitimap 就是一个 key 对应多个 value 的数据结构。看上去它很像 java.util.Map 的结构，但是 Muitimap 不是 Map，没有实现 Map 的接口。设想你对 Map 调了 2 次参数 key 一样的 put 方法，结果就是第 2 次的 value 覆盖了第 1 次的 value。但是对 Muitimap 来说这个 key 同时对应了 2 个 value。所以 Map 看上去是 : {k1=v1, k2=v2,...}，而 Muitimap 是 :{k1=[v1, v2, v3], k2=[v7, v8],....}。

举个记名投票的例子。所有选票都放在一个 List<Ticket> 里面，List 的每个元素包括投票人和选举人的名字。我们可以这样写 :

 //Key is candidate name, its value is his voters
 HashMap<String, HashSet<String>> hMap = new HashMap<String, HashSet<String>>();
 for(Ticket ticket: tickets){
    HashSet<String> set = hMap.get(ticket.getCandidate());
    if(set == null){
        set = new HashSet<String>();
        hMap.put(ticket.getCandidate(), set);
    }
    set.add(ticket.getVoter());
 }

我们再来看看 Muitimap 能做些什么 :直接put，它会保存同key多值

 HashMultimap<String, String> map = HashMultimap.create();
 for(Ticket ticket: tickets){
    map.put(ticket.getCandidate(), ticket.getVoter());
 }

就这么简单！

Muitimap 接口的主要实现类有：

  • HashMultimap: key 放在 HashMap，而 value 放在 HashSet，即一个 key 对应的 value 不可重复
  • ArrayListMultimap: key 放在 HashMap，而 value 放在 ArrayList，即一个 key 对应的 value 有顺序可重复
  • LinkedHashMultimap: key 放在 LinkedHashMap，而 value 放在 LinkedHashSet，即一个 key 对应的 value 有顺序不可重复
  • TreeMultimap: key 放在 TreeMap，而 value 放在 TreeSet，即一个 key 对应的 value 有排列顺序
  • ImmutableMultimap: 不可修改的 Multimap

BiMap: 双向 Map

BiMap 实现了 java.util.Map 接口。它的特点是它的 value 和它 key 一样也是不可重复的，换句话说它的 key 和 value 是等价的。如果你往 BiMap 的 value 里面放了重复的元素，就会得到 IllegalArgumentException。

举个例子，你可能经常会碰到在 Map 里面根据 value 值来反推它的 key 值的逻辑：

 for(Map.Entry<User, Address> entry : map.entreSet()){
    if(entry.getValue().equals(anAddess)){
        return entry.getKey();
    }
 }
 return null;

如果把 User 和 Address 都放在 BiMap，那么一句代码就得到结果了：

 return biMap.inverse().get(anAddess);

这里的 inverse 方法就是把 BiMap 的 key 集合 value 集合对调，因此 biMap == biMap.inverse().inverse()。

BiMap的常用实现有：

HashBiMap: key 集合与 value 集合都有 HashMap 实现

EnumBiMap: key 与 value 都必须是 enum 类型

ImmutableBiMap: 不可修改的 BiMap

MapMaker: 超级强大的 Map 构造工具

MapMaker 是用来构造 ConcurrentMap 的工具类。为什么可以把 MapMaker 叫做超级强大？看了下面的例子你就知道了。首先，它可以用来构造 ConcurrentHashMap:得到线程安全的hashMap

 //ConcurrentHashMap with concurrency level 8
 ConcurrentMap<String, Object> map1 = new MapMaker()
    .concurrencyLevel(8)
     .makeMap();

或者构造用各种不同 reference 作为 key 和 value 的 Map:

 //ConcurrentMap with soft reference key and weak reference value
 ConcurrentMap<String, Object> map2 = new MapMaker()
    .softKeys()
    .weakValues()
    .makeMap();

或者构造有自动移除时间过期项的 Map:存放30秒后移除，可以用于存放请求的场景

 //Automatically removed entries from map after 30 seconds since they are created
 ConcurrentMap<String, Object> map3 = new MapMaker()
    .expireAfterWrite(30, TimeUnit.SECONDS)
    .makeMap();

或者构造有最大限制数目的 Map：限制存放数据

 //Map size grows close to the 100, the map will evict
 //entries that are less likely to be used again
 ConcurrentMap<String, Object> map4 = new MapMaker()
    .maximumSize(100)
    .makeMap();

或者提供当 Map 里面 get 不到数据，它能够自动加入到 Map 的功能。这个功能当 Map 作为缓存的时候很有用 :

 //Create an Object to the map, when get() is missing in map
 ConcurrentMap<String, Object> map5 = new MapMaker()
    .makeComputingMap(
      new Function<String, Object>() {
        public Object apply(String key) {
          return createObject(key);
    }});

这些还不是最强大的特性，最厉害的是 MapMaker 可以提供拥有以上所有特性的 Map:

 //Put all features together!
 ConcurrentMap<String, Object> mapAll = new MapMaker()
    .concurrencyLevel(8)
    .softKeys()
    .weakValues()
    .expireAfterWrite(30, TimeUnit.SECONDS)
    .maximumSize(100)
    .makeComputingMap(
      new Function<String, Object>() {
        public Object apply(String key) {
          return createObject(key);
     }});

Ordering class: 灵活的多字段排序比较器

要对集合排序或者求最大值最小值，首推 java.util.Collections 类，但关键是要提供 Comparator 接口的实现。假设有个待排序的 List<Foo>，而 Foo 里面有三个排序关键字 int a, int b 和 int c:

 Collections.sort(list, new Comparator<Foo>(){
    @Override
    public int compare(Foo f1, Foo f2) {
        int resultA = f1.a – f2.a;
        int resultB = f1.b – f2.b;
        return  resultA == 0 ? (resultB == 0 ? f1.c – f2.c : resultB) : resultA;

}});

这看上去有点眼晕，如果用一串 if-else 也好不到哪里去。看看 ComparisonChain 能做到什么 :

 Collections.sort(list, new Comparator<Foo>(){
    @Override
    return ComparisonChain.start()
         .compare(f1.a, f2.a)
         .compare(f1.b, f2.b)
         .compare(f1.c, f2.c).result();
         }});

如果排序关键字要用自定义比较器，compare 方法也有接受 Comparator 的重载版本。譬如 Foo 里面每个排序关键字都已经有了各自的 Comparator，那么利用 ComparisonChain 可以 :

 Collections.sort(list, new Comparator<Foo>(){
    @Override
    return ComparisonChain.start()
         .compare(f1.a, f2.a, comparatorA)
         .compare(f1.b, f2.b, comparatorB)
         .compare(f1.c, f2.c, comparatorC).result();
         }});

Ordring 类还提供了一个组合 Comparator 对象的方法。而且 Ordring 本身实现了 Comparator 接口所以它能直接作为 Comparator 使用：

 Ordering<Foo> ordering = Ordering.compound(     Arrays.asList(comparatorA, comparatorB, comparatorc));
 Collections.sort(list, ordering);

其他特性 :

过滤器：利用 Collections2.filter() 方法过滤集合中不符合条件的元素。譬如过滤一个 List<Integer> 里面小于 10 的元素 :

 Collection<Integer>  filterCollection =
        Collections2.filter(list, new Predicate<Integer>(){
    @Override
    public boolean apply(Integer input) {
        return input >= 10;
 }});

当然，你可以自己写一个循环来实现这个功能，但是这样不能保证之后小于 10 的元素不被放入集合。filter 的强大之处在于返回的 filterCollection 仍然有排斥小于 10 的元素的特性，如果调 filterCollection.add(9) 就会得到一个 IllegalArgumentException。

转换器：利用 Collections2.transform() 方法来转换集合中的元素。譬如把一个 Set<Integer> 里面所有元素都转换成带格式的 String 来产生新的 Collection<String>:

 Collection<String>  formatCollection =
      Collections2.transform(set, new Function<Integer, String>(){
    @Override
    public String apply(Integer input) {
        return new DecimalFormat("#,###").format(input);
 }} );
时间： 2024-08-07 00:06:21

guava总结的相关文章

Guava：好用的java类库 学习小记

基础功能 google guava中定义的String操作 在google guava中为字符串操作提供了很大的便利,有老牌的判断字符串是否为空字符串或者为null,用指定字符填充字符串,以及拆分合并字符串,字符串匹配的判断等等. 1. 使用com.google.common.base.Strings类的isNullOrEmpty(input)方法判断字符串是否为空 1 //Strings.isNullOrEmpty(input) demo 2 String input = ""; 3

学习笔记（二） 瓜娃（guava）的API快速熟悉使用

1,大纲 让我们来熟悉瓜娃,并体验下它的一些API,分成如下几个部分: Introduction Guava Collection API Guava Basic Utilities IO API Cache API 2,为神马选择瓜娃? 瓜娃是java API蛋糕上的冰激凌(精华) 高效设计良好的API. 被google的开发者设计,实现和使用. 遵循高效的java这本书的好的语法实践. 使代码更刻度,简洁,简单. 使用java 1.5的特性, 流行的API,动态的开发 它提供了大量相关的应用

开源介绍：Google Guava、Google Guice、Joda-Time

一.Guava 是一个 Google 的基于java1.6的类库集合的扩展项目,包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你的JAVa代码更加优雅,更加简洁,让你工作更加轻松愉悦.下面我们就开启优雅Java编程学习之旅! 项目相关信息: 官方首页:http://code.googl

guava Splitter 与java　内置的string的split　方法有什么区别．

java内置的会忽略空内容,guava Splitter不会忽略.或者可以自由选择的忽略． /** * {@code Splitter}和{@code Joiner} 这两个对于map的相反的操作,在web框架例如spring mvc中用到过． * * 对于get url后面的参数和pos form中前端参数的连接和后端的拆分都有用到．每个框架的处理思维是一样的． * * @author doctor * * @since 2015年3月14日 下午9:00:17 */ ．．．．．．．．．．．．

Guava源码学习（二）Ordering

基于版本:Guava 22.0 Wiki:Ordering 0. Ordering简介 Guava的Ordering提供了链式风格的比较器的实现,我们可以用Ordering轻松构建复杂的比较器. 1. 类图 这张类图不完全,实际上Ordering有十几个子类,这些子类共同提供了复杂的功能. 2. 设计思路 Ordering是继承于java.util.Comparator接口的抽象类,它的十几个子类都实现了compare与equals方法,这些子类可以实现基本的排序功能. 通过链式调用,可以将这些

guava cache与spring集成

缓存的背景 缓存,在我们日常开发中是必不可少的一种解决性能问题的方法.简单的说,cache 就是为了提升系统性能而开辟的一块内存空间.在cpu进行计算的时候, 首先是读取寄存器,然后内存,再是硬盘.由于寄存器容量很小,不太适合存储我们需要快速读取的数据,放在硬盘中话,效率太低,所以大多数人将一些静态资源或者不经常修改的数据放在内存中. 缓存的作用 缓存的主要作用是暂时在内存中保存业务系统的数据处理结果,并且等待下次访问使用.在日常开发的很多场合,由于受限于硬盘 IO的性能或者我们自身业务系统的数

guava学习--集合2

Table: 当我们需要多个索引的数据结构的时候,通常情况下,我们只能用这种丑陋的Map<FirstName, Map<LastName, Person>>来实现.为此Guava提供了一个新的集合类型-Table集合类型,来支持这种数据结构的使用场景.Table支持"row"和"column",而且提供多种视图. Table<String, Integer, String> aTable = HashBasedTable.crea

guava学习--Supplier Suppliers

转载:http://www.cnblogs.com/jun-ma/p/4850591.html Guava Suppliers的主要功能是创建包裹的单例对象,通过get方法可以获取对象的值.每次获取的对象都为同一个对象,但你和单例模式有所区别,Suppliers具备更加迷人的色彩. Lazy初始化,Supplier wrapped的对象只在第一次get时候会被初始化 public void should_init_the_supplier_wrapped_object_when_get_obje

缓存框架Guava Cache部分源码分析

在本地缓存中,最常用的就是OSCache和谷歌的Guava Cache.其中OSCache在07年就停止维护了,但它仍然被广泛的使用.谷歌的Guava Cache也是一个非常优秀的本地缓存,使用起来非常灵活,功能也十分强大,可以说是当前本地缓存中最优秀的缓存框架之一.之前我们分析了OSCache的部分源码,本篇就通过Guava Cache的部分源码,来分析一下Guava Cache的实现原理. 在分析之前,先弄清数据结构的使用.之前的文章提到,OSCache使用了一个扩展的HashTable,作

Guava: 事件总线EventBus

EventBus 直译过来就是事件总线,它使用发布订阅模式支持组件之间的通信,不需要显式地注册回调,比观察者模式更灵活,可用于替换Java中传统的事件监听模式,EventBus的作用就是解耦,它不是通用的发布订阅系统,也不能用于进程间通信.可用于Android的EventBus库主要有这几个:Google出品的Guava,Guava是一个庞大的库,EventBus 只是它附带的一个小功能,因此实际项目中使用并不多.用的最多的是greenrobot/EventBus,这个库的优点是接口简洁,集成方