1. 云图网首页
  2. 业界资讯

Guava代码学习笔记详解编程语言

• 业界资讯

Guava 是一个 Google 的基于java1.6的类库集合的扩展项目，包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你的JAVa代码更加优雅，更加简洁，让你工作更加轻松愉悦。

项目相关信息：

　　官方首页：http://code.google.com/p/guava-libraries
　　官方下载：http://code.google.com/p/guava-libraries/downloads/list
　　官方文档：http://docs.guava-libraries.googlecode.com/git/javadoc
                    http://www.ostools.net/apidocs/apidoc?api=guava

    在线文档查看：http://www.boyunjian.com/javadoc/com.google.guava/guava-jdk5/14.0.1/_/com/google/common/base/Objects.ToStringHelper.html

　　源码包的简单说明： 
　　com.google.common.annotations：普通注解类型。 
　　com.google.common.base：基本工具类库和接口。 
　　com.google.common.cache：缓存工具包，非常简单易用且功能强大的JVM内缓存。 
　　com.google.common.collect：带泛型的集合接口扩展和实现，以及工具类，这里你会发现很多好玩的集合。 
　　com.google.common.eventbus：发布订阅风格的事件总线。 
　　com.google.common.hash： 哈希工具包。 
　　com.google.common.io：I/O工具包。 
　　com.google.common.math：原始算术类型和超大数的运算工具包。 
　　com.google.common.net：网络工具包。 
　　com.google.common.primitives：八种原始类型和无符号类型的静态工具包。 
　　com.google.common.reflect：反射工具包。 
　　com.google.common.util.concurrent：多线程工具包。

最新的maven坐标：

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

类库使用手册：

　　一.  基本工具类：让使用Java语言更令人愉悦。

　　1. 使用和避免 null：null 有语言歧义， 会产生令人费解的错误， 反正他总是让人不爽。很多 Guava 的工具类在遇到 null 时会直接拒绝或出错，而不是默默地接受他们。
　　2. 前提条件：更容易的对你的方法进行前提条件的测试。
　　3. 常见的对象方法： 简化了Object常用方法的实现， 如 hashCode() 和 toString()。
　　4. 排序： Guava 强大的 “fluent Comparator”比较器， 提供多关键字排序。
　　5. Throwable类： 简化了异常检查和错误传播。

　　二.  集合类：集合类库是 Guava 对 JDK 集合类的扩展， 这是 Guava 项目最完善和为人所知的部分。

　　1. Immutable collections（不变的集合）： 防御性编程， 不可修改的集合，并且提高了效率。
　　2. New collection types(新集合类型)：JDK collections 没有的一些集合类型，主要有：multisets，multimaps，tables， bidirectional maps等等
　　3. Powerful collection utilities（强大的集合工具类）： java.util.Collections 中未包含的常用操作工具类
　　4. Extension utilities（扩展工具类）: 给 Collection 对象添加一个装饰器? 实现迭代器? 我们可以更容易使用这些方法。

　　三.  缓存: 本地缓存，可以很方便的操作缓存对象，并且支持各种缓存失效行为模式。

　　四.  Functional idioms（函数式）: 简洁, Guava实现了Java的函数式编程，可以显著简化代码。

　　五. Concurrency（并发）：强大,简单的抽象,让我们更容易实现简单正确的并发性代码。

　　1. ListenableFuture（可监听的Future）: Futures,用于异步完成的回调。
　　2. Service: 控制事件的启动和关闭，为你管理复杂的状态逻辑。

　　六. Strings: 一个非常非常有用的字符串工具类: 提供 splitting，joining， padding 等操作。

　　七. Primitives: 扩展 JDK 中未提供的对原生类型（如int、char等）的操作， 包括某些类型的无符号的变量。

　　八. Ranges: Guava 一个强大的 API，提供 Comparable 类型的范围处理， 包括连续和离散的情况。

　　九. I/O: 简化 I/O 操作, 特别是对 I/O 流和文件的操作, for Java 5 and 6.

　　十. Hashing: 提供比 Object.hashCode() 更复杂的 hash 方法, 提供 Bloom filters.

　　十一. EventBus: 基于发布-订阅模式的组件通信，但是不需要明确地注册在委托对象中。

　　十二. Math: 优化的 math 工具类，经过完整测试。

　　十三. Reflection: Guava 的 Java 反射机制工具类。

集合API的使用

　1简化工作

可以简化集合的创建和初始化；

类别 原来的写法 guava的写法
集合创建

Map<String, Map<String, String>> map = new HashMap<String, Map<String,String>>();

List<List<Map<String, String>>> list = new ArrayList<List<Map<String,String>>>();

Map<String, Map<String, String>> map = Maps.newHashMap();

List<List<Map<String, String>>> list = Lists.newArrayList();

//1,简化集合的创建
List<Person> personList= Lists.newLinkedList();
Set<Person> personSet= Sets.newHashSet();
Map<String,Person> personMap= Maps.newHashMap();
Integer[] intArrays= ObjectArrays.newArray(Integer.class,10);
集合初始化  

Set<String> set = new HashSet<String>();

set.add(“one”);

set.add(“two”);

set.add(“three”);

  

Set<String> set = Sets.newHashSet(“one”,”two”,”three”);

List<String> list = Lists.newArrayList(“one”,”two”,”three”);

Map<String, String> map = ImmutableMap.of(“ON”,”TRUE”,”OFF”,”FALSE”);

//2,简化集合的初始化
List<Person> personList2= Lists.newArrayList(new Person(1, 1, “a”, “46546”, 1, 20),

new Person(2, 1, “a”, “46546”, 1, 20));
Set<Person> personSet2= Sets.newHashSet(new Person(1,1,”a”,”46546″,1,20),

new Person(2,1,”a”,”46546″,1,20));
Map<String,Person> personMap2= ImmutableMap.of(“hello”,new Person(1,1,”a”,”46546″,1,20),”fuck”,new Person(2,1,”a”,”46546″,1,20));

创建不可变的集合

ImmutableList<Person> personImmutableList= ImmutableList.of(new Person(1, 1, "a", "46546", 1, 20), new Person(2, 1, "a", "46546", 1, 20));  ImmutableSet<Person> personImmutableSet=ImmutableSet.copyOf(personSet2);  ImmutableMap<String,Person> personImmutableMap=ImmutableMap.<String,Person>builder() .put("hell",new Person(1,1,"a","46546",1,20)).putAll(personMap2) .build();

新的集合类型

The Guava API provides very useful new collection types that work very nicely with existing java collections.

guava API 提供了有用的新的集合类型，协同已经存在的java集合工作的很好。

分别是 MultiMap， MultiSet， Table， BiMap， ClassToInstanceMap

种类 写的例子
MultiMap

一种key可以重复的map，子类有ListMultimap和SetMultimap，对应的通过key分别得到list和set

Multimap<String, Person> customersByType =ArrayListMultimap.create();customersByType.put(“abc”, new Person(1, 1, “a”, “46546”, 1, 20));

customersByType.put(“abc”, new Person(1, 1, “a”, “46546”, 1, 30));
customersByType.put(“abc”, new Person(1, 1, “a”, “46546”, 1, 40));
customersByType.put(“abc”, new Person(1, 1, “a”, “46546”, 1, 50));
customersByType.put(“abcd”, new Person(1, 1, “a”, “46546”, 1, 50));
customersByType.put(“abcde”, new Person(1, 1, “a”, “46546”, 1, 50));

for(Person person:customersByType.get(“abc”))
{
System.out.println(person.getAge());
}
MultiSet

 

不是集合，可以增加重复的元素，并且可以统计出重复元素的个数，例子如下：

private static void testMulitiSet() {
Multiset<Integer> multiSet = HashMultiset.create();
multiSet.add(10);
multiSet.add(30);
multiSet.add(30);
multiSet.add(40);

System.out.println( multiSet.count(30)); // 2
System.out.println( multiSet.size()); //4
}
Table

 

相当于有两个key的map，不多解释

private static void testTable() {
Table<Integer,Integer,Person> personTable=HashBasedTable.create();
personTable.put(1,20,new Person(1, 1, “a”, “46546”, 1, 20));
personTable.put(0,30,new Person(2, 1, “ab”, “46546”, 0, 30));
personTable.put(0,25,new Person(3, 1, “abc”, “46546”, 0, 25));
personTable.put(1,50,new Person(4, 1, “aef”, “46546”, 1, 50));
personTable.put(0,27,new Person(5, 1, “ade”, “46546”,0, 27));
personTable.put(1,29,new Person(6, 1, “acc”, “46546”, 1, 29));
personTable.put(0,33,new Person(7, 1, “add”, “46546”,0, 33));
personTable.put(1,66,new Person(8, 1, “afadsf”, “46546”, 1, 66));

//1,得到行集合
Map<Integer,Person> rowMap= personTable.row(0);
int maxAge= Collections.max(rowMap.keySet());

}
BiMap 是一个一一映射，可以通过key得到value，也可以通过value得到key； 

private static void testBitMap() {
//双向map
BiMap<Integer,String> biMap=HashBiMap.create();

biMap.put(1,”hello”);
biMap.put(2,”helloa”);
biMap.put(3,”world”);
biMap.put(4,”worldb”);
biMap.put(5,”my”);
biMap.put(6,”myc”);

int value= biMap.inverse().get(“my”);
System.out.println(“my –“+value);

}
ClassToInstanceMap  

有的时候，你的map的key并不是一种类型，他们是很多类型，你想通过映射他们得到这种类型，guava提供了ClassToInstanceMap满足了这个目的。
 
除了继承自Map接口，ClassToInstaceMap提供了方法 
T getInstance(Class<T>) 和 
T putInstance(Class<T>, T),消除了强制类型转换。
 
该类有一个简单类型的参数，通常称为B，代表了map控制的上层绑定，例如：
  
ClassToInstanceMap<Number> numberDefaults = MutableClassToInstanceMap.create();
numberDefaults.putInstance(Integer.class, Integer.valueOf(0));
从技术上来说，
ClassToInstanceMap<B> 实现了
Map<Class<? extends B>, B>，或者说，这是一个从B的子类到B对象的映射，这可能使得
ClassToInstanceMap的泛型轻度混乱，但是只要记住B总是Map的上层绑定类型，通常来说B只是一个对象。

guava提供了有用的实现，
 
MutableClassToInstanceMap
 和
 
ImmutableClassToInstanceMap
.
重点：像其他的Map<Class,Object>,
ClassToInstanceMap 含有的原生类型的项目，一个原生类型和他的相应的包装类可以映射到不同的值；

private static void testClass() {
ClassToInstanceMap<Person> classToInstanceMap =MutableClassToInstanceMap.create();

Person person= new Person(1,20,”abc”,”46464″,1,100);

classToInstanceMap.putInstance(Person.class,person);

// System.out.println(“string:”+classToInstanceMap.getInstance(String.class));
// System.out.println(“integer:” + classToInstanceMap.getInstance(Integer.class));

Person person1=classToInstanceMap.getInstance(Person.class);

}

 排序

 是guava一份非常灵活的比较类，可以被用来操作，扩展，当作比较器，排序提供了集合排序的很多控制；

实例如下：

Lists.newArrayList(30, 20, 60, 80, 10); 
 
Ordering.natural().sortedCopy(numbers); //10,20,30,60,80 
 
Ordering.natural().reverse().sortedCopy(numbers); //80,60,30,20,10 
 
Ordering.natural().min(numbers); //10 
 
Ordering.natural().max(numbers); //80 
 
Lists.newArrayList(30, 20, 60, 80, null, 10); 
 
Ordering.natural().nullsLast().sortedCopy(numbers); //10, 20,30,60,80,null 
 
Ordering.natural().nullsFirst().sortedCopy(numbers); //null,10,20,30,60,80 
 
  
 
public static void testOrdering() 
{ 
List<Person> personList=Lists.newArrayList( 
new Person(3, 1, "abc", "46546", 0, 25), 
new Person(2, 1, "ab", "46546", 0, 30), 
new Person(5, 1, "ade", "46546",0, 27), 
new Person(1, 1, "a", "46546", 1, 20), 
new Person(6, 1, "acc", "46546", 1, 29), 
new Person(4, 1, "aef", "46546", 1, 50), 
new Person(7, 1, "add", "46546",0, 33) 
); 
 
Ordering<Person> byAge=new Ordering<Person>() { 
@Override 
public int compare( Person left, Person right) { 
return right.getAge()-left.getAge(); 
} 
}; 
 
for(Person p: byAge.immutableSortedCopy(personList)) 
{ 
System.out.println(p); 
} 
}

下面的例子为Guava重写的toString（）方法的例子： 

// 重写PhoneNumber的toString方法 - Effective Java中文第二版第44页 package org.effectivejava.examples.chapter03.item10;  import java.util.HashMap; import java.util.Map;  import com.google.common.base.Objects;  public final class PhoneNumber {         private final short areaCode;         private final short prefix;         private final short lineNumber;          public PhoneNumber(int areaCode, int prefix, int lineNumber) {                 rangeCheck(areaCode, 999, "area code");                 rangeCheck(prefix, 999, "prefix");                 rangeCheck(lineNumber, 9999, "line number");                 this.areaCode = (short) areaCode;                 this.prefix = (short) prefix;                 this.lineNumber = (short) lineNumber;         }          private static void rangeCheck(int arg, int max, String name) {                 if (arg < 0 || arg > max)                         throw new IllegalArgumentException(name + ": " + arg);         }          @Override         public boolean equals(Object o) {                 if (o == this)                         return true;                 if (!(o instanceof PhoneNumber))                         return false;                 PhoneNumber pn = (PhoneNumber) o;                 return pn.lineNumber == lineNumber && pn.prefix == prefix                                 && pn.areaCode == areaCode;         }          @Override         public int hashCode() {                 int result = 17;                 result = 31 * result + areaCode;                 result = 31 * result + prefix;                 result = 31 * result + lineNumber;                 return result;         }      //Effective Java原有的toString方法         /*          * @Override public String toString() { return          * String.format("(%03d) %03d-%04d", areaCode, prefix, lineNumber); }          */          /**          * 采用Guava实现的toString          *          */         @Override         public String toString() {                 return Objects.toStringHelper(this)                                 .addValue(String.format("(%03d) %03d-%04d", areaCode, prefix,lineNumber))                                 .add("areaCode", areaCode)                                 .add("prefix", prefix)                                 .add("lineNumber", lineNumber)                                 .toString();         }          public static void main(String[] args) {                 Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();                 m.put(new PhoneNumber(707, 867, 5309), "Jenny");                  System.out.println(m);         } }

输出结果如下： 

//原输出 {(707) 867-5309=Jenny}    //Guava实现输出  {PhoneNumber{(707) 867-5309, areaCode=707, prefix=867, lineNumber=5309}=Jenny}

原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/13743.html

赞 (0)
0
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论