`
chenjingbo
  • 浏览: 459653 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

Guava总结3-Collections

 
阅读更多

  在整理Guava Collections部分的时候,发现一篇神文.老实说,我个人想不出需要添加的地方了,直接复制了对应的内容.原文地址

http://www.ibm.com/developerworks/cn/java/j-lo-googlecollection/      

 

  Google Guava Collections(以下都简称为 Guava Collections)是 Java Collections Framework 的增强和扩展。每个 Java 开发者都会在工作中使用各种数据结构,很多情况下 Java Collections Framework 可以帮助你完成这类工作。但是在有些场合你使用了 Java Collections Framework 的 API,但还是需要写很多代码来实现一些复杂逻辑,这个时候就可以尝试使用 Guava Collections 来帮助你完成这些工作。这些高质量的 API 使你的代码更短,更易于阅读和修改,工作更加轻松。

 

1 创建集合

    基本很简单,还是非常建议使用的,具体代码如下

 //jdk6
        List<String> normalList = new ArrayList<String>();
        //jdk7
        List<String> jdk7List = new ArrayList<>();
        //guava
        List<String> guavaList = Lists.newArrayList();
        //list add by jdk
        normalList.add("1");
        normalList.add("2");
        normalList.add("3");
        //list add by guava
        guavaList = Lists.newArrayList("1","2","3");

        //jdk6
        Map<String,Integer> normalMap = new HashMap<String,Integer>();
        Map<String,Integer> jdk7Map = new HashMap<>();
        Map<String,Integer> guavalMap = Maps.newHashMap();

 list的转换可以参考下面代码

private DefaultFrontCatClientTO build(Long categoryId){
        if(categoryId == null || categoryId == 0l) return null;
        return new DefaultFrontCatClientTO(categoryId);
    }
    private List<DefaultFrontCatClientTO> build(List<Long> categoryIds){
        if(categoryIds == null || categoryIds.isEmpty()) return Collections.EMPTY_LIST;
        return Lists.transform(categoryIds,new Function<Long,DefaultFrontCatClientTO>(){

            @Override
            public DefaultFrontCatClientTO apply(@Nullable Long input) {
                return build(input);
            }
        });
    }

 

 

 

  2 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 能做些什么 :

 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:

 //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:

 //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); 
     }}); 

 

 

其他特性 :

过滤器:利用 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); 
 }} ); 
分享到:
评论

相关推荐

    guava-collections-r03.jar

    guava类似Apache Commons工具集包含了若干被Google的 Java项目广泛依赖 的核心库

    Google-Guava-Collections-使用介绍

    ### Google Guava Collections 使用介绍 #### 一、概述 Google Guava Collections 是 Java Collections Framework 的一个强大且实用的非官方扩展 API。它由 Google 工程师 Kevin Bourrillion 和 Jared Levy 在著名...

    commons-beanutils、commons-collections、commons-collections等常用jar 包下载

    2. **Apache Commons Collections** - `commons-collections-3.2.2.jar` 这个库扩展了Java集合框架,提供了许多额外的数据结构和算法。它包含: - 高级集合实现:如双向队列、堆栈、映射、多重集(Multiset)等。 ...

    google-collections-1.0-rc2.jar

    google-collections-1.0-rc2.jar 的jar包,放心使用。

    guava-gwt-18.0.jar

    The Guava project contains several of Google's core libraries that we rely on in our Java-based projects: collections, caching, primitives support, concurrency libraries, common annotations, string ...

    mahout的guava-r09-jar

    4. **函数式编程**:Guava的Predicates、Functions和Collections2等工具,支持函数式编程风格,使得代码更简洁且易于测试。 5. **I/O工具**:例如Files类提供了一系列静态方法,简化了文件操作,而CharMatcher则...

    guava-19.0 jar和sources

    这个版本的Guava提供了如ListMultimap、Table、Optional等数据结构,以及Preconditions、CheckState等代码质量检查工具,还有诸如FluentIterable、Iterables、Collections2等增强的集合操作方法。此外,它还包含了对...

    google-collections jar包

    Google Collections,现在被称为Guava库,是Google推出的一个Java工具包,主要用于增强Java的集合框架。这个库包含了丰富的数据结构、工具类和实用方法,极大地提高了开发效率,优化了代码质量。在Java项目中,我们...

    Guava官方教程-中文

    集合(collections) 缓存(caching) 原生的类型支持(primitives support) 并发类库(concurrency libraries) 通用注解(common annotations) 字符串处理(string processing) 输入/输出(I/O),等等

    Guava及扩展组件资源大全:含最新及历史各版本Jar、源代码

    扩展组件包括guava-annotations、guava-base、guava-bootstrap、guava-collections、guava-concurrent、guava-gwt、guava-io、guava-parent、guava-primitives、listenablefuture、guava-testlib等。

    guava jar guava-r07.jar

    Guava是一个Google 的基于java1.6的类库集合的扩展项目,包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O

    java-collections-framework1016

    除了Java标准库提供的集合外,还有其他第三方库提供了额外的集合实现,例如Google Guava库,它提供了更多功能丰富的集合实现,如`Multiset`、`Multimap`等。 #### 七、练习 教程最后包含了一些练习题,帮助读者...

    Google的Guava工具包

    Guava 是一个 Google 的基于java1.6的类库集合的扩展项目,包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你...

    google guava23.5

    - **Immutable Collections**:不可变的集合类,确保一旦创建就不能被修改,提供线程安全。 - **BiMap**:双向映射,允许在键和值之间进行双向查找。 - **Table**:二维表格数据结构,用于存储键-键对的数据。 2...

    google-collections.zip

    这个压缩包 "google-collections.zip" 包含了 "google-collections-1.0.1.jar" 文件,这正是 Google Collections 的一个早期版本。这个库后来发展成为现在的 Guava 库,是许多 Java 开发者在编写高效、健壮代码时的...

    guava-jdk5

    7. **流(Stream)操作**:虽然Java 5本身不支持Stream API,但Guava的Iterables和Collections提供了类似的功能,如FluentIterable,允许进行链式操作,实现数据的过滤、转换等。 8. **事件监听**:Guava的 EventBus ...

    jackson-datatype-guava-2.8.0.zip

    在`jackson-datatypes-collections-master`中,我们可以预期找到源码和相关文档,包括: 1. **源码**:包含了处理Guava数据类型的序列化和反序列化的实现,比如`com.fasterxml.jackson.datatype.guava.GuavaModule`...

    guava-18.0.rar

    Guava 是 Google 开发的一个广泛使用的 Java 库,它的全称是 Google Collections Library,后来更名为 Guava。Guava 提供了一系列高效、实用的工具类,极大地丰富了 Java 标准库的功能,尤其在集合框架、并发处理、I...

    Google_Guava_Collections_使用介绍.pdf )

    ### Google Guava Collections 使用介绍 #### 一、Google Guava Collections 概览 Google Guava Collections,简称Guava Collections,是对Java Collections Framework进行增强和扩展的开源项目。它由Google工程师...

Global site tag (gtag.js) - Google Analytics