?【Java技术指南】「Guava Collections」实战使用相关Guava不一般的集合框架

时间:2021-08-22 14:15:57   收藏:0   阅读:12

Google Guava Collections 使用介绍

简介

Google Guava Collections 是一个对 Java Collections Framework 增强和扩展的一个开源项目。由于它高质量 API 的实现和对 Java特性的充分利用,使得其在 Java 社区受到很高评价。笔者主要介绍它的基本用法和功能特性。

使用介绍

目标读者

项目背景


集合介绍


Immutable Collections: 真正的不可修改的集合
Set<String> set = new HashSet<String>(Arrays.asList(new String[]{"RED", "GREEN"})); 
Set<String> unmodifiableSet = Collections.unmodifiableSet(set);

构造这样一个简单的set写了两句长的代码。下面看看ImmutableSet 是怎么来做地更安全和简洁 :

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

从构造的方式来说,ImmutableSet 集合还提供了 Builder 模式来构造一个集合 :在这个例子里面 Builder 不但能加入单个元素还能加入既有的集合。

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

Guava Collections 还提供了各种 Immutable 集合的实现

 ImmutableSet.of(4, 8, 15, 16, 23, 42);
 ImmutableSet.copyOf(numbers);
public static final ImmutableMap<String, Integer>
 ENGLISH_TO_INT = ImmutableMap
 .with("four", 4)
 .with("eight", 8)
 .with("fifteen", 15)
 .with("sixteen", 16)
 .with("twenty-three", 23)
 .with("forty-two", 42)
 .build();

ImmutableMap.of(1, "one", 2, "two");

Multiset: 把重复的元素放入集合
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 接口的类有:

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

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

Multimap就是一个 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],....}。

我们可以这样写 :

//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 接口的主要实现类有:

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;
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); 
 }});
Ordering class: 灵活的多字段排序比较器

要对集合排序或者求最大值最小值,首推 java.util.Collections 类,但关键是要提供 Comparator 接口的实现。假设有 个待排序的 List,而 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);
过滤器(stream-filter)

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

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

转换器(Stream-map)

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

Collection<String> formatCollection = 
 Collections2.transform(set, new Function<Integer, String>(){ 
@Override 
public String apply(Integer input) { 
 return new DecimalFormat("#,###").format(input); 
}} );

总结

以上介绍了 Guava Collections 的一些基本的功能特性。你可以从 guava-libraries 的官方网站下载它的 jar 包和它其他的相关文档。如果你使用 Maven 来管理你的项目依赖包,Maven 中央库也提供了它版本的依赖。最后希望Guava Collections 使你的编程工作更轻松,更有乐趣。

使用

这个开源项目发布的 jar 包可以在它的官方网站内(http://code.google.com/p/guava-libraries/downloads/list)找到。

其下载的 zip 包中含有 Guava Collections 的 jar 包 guava-r09.jar 及其依赖包 guava-r09-gwt.jar,javadoc,源代码,readme 等文件。使用时只需将 guava-r09.jar 和依赖包 guava-r09-gwt.jar 放入 CLASSPATH 中即可。

如果您使用 Maven 作为构建工具的话可以在 pom.xml 内加入:

<dependency> 
<groupId>com.google.guava</groupId> 
<artifactId>guava</artifactId> 
<version>xxx</version> 
</dependency> 

原文:https://www.cnblogs.com/liboware/p/15171506.html

评论(0)
© 2014 bubuko.com 版权所有 - 联系我们:wmxa8@hotmail.com
打开技术之扣,分享程序人生!