转载 谷歌guava工具包详解

概述

工具类 就是封装平常用的方法，不需要你重复造轮子，节省开发人员时间，提高工作效率。谷歌作为大公司，当然会从日常的工作中提取中很多高效率的方法出来。所以就诞生了guava。

guava的优点：

高效设计良好的API，被Google的开发者设计，实现和使用

遵循高效的java语法实践

使代码更刻度，简洁，简单

节约时间，资源，提高生产力

Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：

集合 [collections]

缓存 [caching]

原生类型支持 [primitives support]

并发库 [concurrency libraries]

通用注解 [common annotations]

字符串处理 [string processing]

I/O 等等。

使用

引入gradle依赖（引入Jar包）

compile'com.google.guava:guava:26.0-jre'

1.集合的创建

// 普通Collection的创建

List list = Lists.newArrayList();

Set set = Sets.newHashSet();

Map map = Maps.newHashMap();

// 不变Collection的创建

ImmutableList iList = ImmutableList.of("a","b","c");

ImmutableSet iSet = ImmutableSet.of("e1","e2");

ImmutableMap iMap = ImmutableMap.of("k1","v1","k2","v2");

创建不可变集合 先理解什么是immutable(不可变)对象

在多线程操作下，是线程安全的

所有不可变集合会比可变集合更有效的利用资源

中途不可改变

ImmutableList immutableList = ImmutableList.of("1","2","3","4");

这声明了一个不可变的List集合，List中有数据1，2，3，4。类中的 操作集合的方法（譬如add, set, sort, replace等）都被声明过期，并且抛出异常。 而没用guava之前是需要声明并且加各种包裹集合才能实现这个功能

// add 方法

@Deprecated@Override

publicfinalvoidadd(intindex, E element){

thrownewUnsupportedOperationException();

  }

当我们需要一个map中包含key为String类型，value为List类型的时候，以前我们是这样写的

Map> map =newHashMap>();

Listlist=newArrayList();

list.add(1);

list.add(2);

map.put("aa",list);

System.out.println(map.get("aa"));//[1, 2]

而现在

Multimapmap=ArrayListMultimap.create();

map.put("aa",1);

map.put("aa",2);

System.out.println(map.get("aa"));//[1, 2]

其他的黑科技集合

MultiSet: 无序+可重复  count()方法获取单词的次数  增强了可读性+操作简单

创建方式:  Multiset set = HashMultiset.create();

Multimap: key-value  key可以重复 

创建方式: Multimap teachers = ArrayListMultimap.create();

BiMap: 双向Map(BidirectionalMap) 键与值都不能重复

创建方式:  BiMap biMap = HashBiMap.create();

Table: 双键的MapMap--> Table-->rowKey+columnKey+value//和sql中的联合主键有点像

创建方式: Table tables = HashBasedTable.create();

...等等(guava中还有很多java里面没有给出的集合类型)

2.将集合转换为特定规则的字符串

以前我们将list转换为特定规则的字符串是这样写的:

//use java

Listlist=newArrayList();

list.add("aa");

list.add("bb");

list.add("cc");

String str ="";

for(int i=0; i

str = str +"-"+list.get(i);

}

//str 为-aa-bb-cc

//use guava

Listlist=newArrayList();

list.add("aa");

list.add("bb");

list.add("cc");

String result = Joiner.on("-").join(list);

//result为  aa-bb-cc

把map集合转换为特定规则的字符串

Mapmap=Maps.newHashMap();

map.put("xiaoming",12);

map.put("xiaohong",13);

Stringresult =Joiner.on(",").withKeyValueSeparator("=").join(map);

// result为 xiaoming=12,xiaohong=13

3.将String转换为特定的集合

//use java

List list =newArrayList();

Stringa ="1-2-3-4-5-6";

String[] strs = a.split("-");

for(int i=0; i

    list.add(strs[i]);

}

//use guava

Stringstr ="1-2-3-4-5-6";

List list = Splitter.on("-").splitToList(str);

//list为  [1, 2, 3, 4, 5, 6]

如果

str="1-2-3-4- 5-  6  ";

guava还可以使用omitEmptyStrings().trimResults()去除空串与空格

Stringstr ="1-2-3-4-  5-  6  ";

List list = Splitter.on("-").omitEmptyStrings().trimResults().splitToList(str);

System.out.println(list);

将String转换为map

Stringstr ="xiaoming=11,xiaohong=23";

Map map = Splitter.on(",").withKeyValueSeparator("=").split(str);

4.guava还支持多个字符切割，或者特定的正则分隔

Stringinput ="aa.dd,,ff,,.";

List result = Splitter.onPattern("[.|,]").omitEmptyStrings().splitToList(input);

关于字符串的操作 都是在Splitter这个类上进行的

// 判断匹配结果

booleanresult = CharMatcher.inRange('a','z').or(CharMatcher.inRange('A','Z')).matches('K');//true

// 保留数字文本  CharMatcher.digit() 已过时  retain 保留

//String s1 = CharMatcher.digit().retainFrom("abc 123 efg"); //123

String s1 = CharMatcher.inRange('0','9').retainFrom("abc 123 efg");// 123

// 删除数字文本  remove 删除

// String s2 = CharMatcher.digit().removeFrom("abc 123 efg");    //abc  efg

String s2 = CharMatcher.inRange('0','9').removeFrom("abc 123 efg");// abc  efg

5. 集合的过滤

我们对于集合的过滤，思路就是迭代，然后再具体对每一个数判断，这样的代码放在程序中，难免会显得很臃肿，虽然功能都有，但是很不好看。

guava写法

//按照条件过滤

ImmutableList names = ImmutableList.of("begin","code","Guava","Java");

Iterable fitered = Iterables.filter(names, Predicates.or(Predicates.equalTo("Guava"), Predicates.equalTo("Java")));

System.out.println(fitered);// [Guava, Java]

//自定义过滤条件  使用自定义回调方法对Map的每个Value进行操作

ImmutableMap m = ImmutableMap.of("begin",12,"code",15);

// Function F表示apply()方法input的类型，T表示apply()方法返回类型

Map m2 = Maps.transformValues(m,newFunction() {

publicIntegerapply(Integer input){

if(input>12){

returninput;

}else{

returninput+1;

                }

            }

        });

System.out.println(m2);//{begin=13, code=15}

set的交集, 并集, 差集

HashSet setA = newHashSet(1,2,3,4,5);

HashSet setB = newHashSet(4,5,6,7,8);

SetView union = Sets.union(setA, setB);   

System.out.println("union:");

for(Integer integer : union)

System.out.println(integer);//union 并集:12345867

SetView difference = Sets.difference(setA, setB); 

System.out.println("difference:");

for(Integer integer : difference)

System.out.println(integer);//difference 差集:123

SetView intersection = Sets.intersection(setA, setB); 

System.out.println("intersection:");

for(Integer integer : intersection)

System.out.println(integer);//intersection 交集:45

map的交集，并集，差集

HashMap mapA = Maps.newHashMap();

mapA.put("a",1);mapA.put("b",2);mapA.put("c",3);

HashMap mapB = Maps.newHashMap();

mapB.put("b",20);mapB.put("c",3);mapB.put("d",4);

MapDifference differenceMap = Maps.difference(mapA, mapB);

differenceMap.areEqual();

Map entriesDiffering = differenceMap.entriesDiffering();

Map entriesOnlyLeft = differenceMap.entriesOnlyOnLeft();

Map entriesOnlyRight = differenceMap.entriesOnlyOnRight();

Map entriesInCommon = differenceMap.entriesInCommon();

System.out.println(entriesDiffering);// {b=(2, 20)}

System.out.println(entriesOnlyLeft);// {a=1}

System.out.println(entriesOnlyRight);// {d=4}

System.out.println(entriesInCommon);// {c=3}

6.检查参数

//use java

if(list!=null&& list.size()>0)

'''

if(str!=null && str.length()>0)

'''

if(str !=null&& !str.isEmpty())

//use guava

if(!Strings.isNullOrEmpty(str))

//use java

if(count <=0) {

thrownewIllegalArgumentException("must be positive: "+ count);

}   

//use guava

Preconditions.checkArgument(count >0,"must be positive: %s", count);

免去了很多麻烦！并且会使你的代码看上去更好看。而不是代码里面充斥着!=null，!=""

检查是否为空,不仅仅是字符串类型，其他类型的判断，全部都封装在 Preconditions类里，里面的方法全为静态

其中的一个方法的源码

@CanIgnoreReturnValue

publicstaticTcheckNotNull(T reference){

if(reference ==null) {

thrownewNullPointerException();

    }

returnreference;

}

方法声明（不包括额外参数）描述检查失败时抛出的异常

checkArgument(boolean)检查boolean是否为true，用来检查传递给方法的参数。IllegalArgumentException

checkNotNull(T)检查value是否为null，该方法直接返回value，因此可以内嵌使用checkNotNull。NullPointerException

checkState(boolean)用来检查对象的某些状态。IllegalStateException

checkElementIndex(int index, int size)检查index作为索引值对某个列表、字符串或数组是否有效。 index > 0 && index < sizeIndexOutOfBoundsException

checkPositionIndexes(int start, int end, int size)检查[start,end]表示的位置范围对某个列表、字符串或数组是否有效IndexOutOfBoundsException

7. MoreObjects

这个方法是在Objects过期后官方推荐使用的替代品，该类最大的好处就是不用大量的重写toString，用一种很优雅的方式实现重写，或者在某个场景定制使用。

Person person =newPerson("aa",11);

String str = MoreObjects.toStringHelper("Person").add("age", person.getAge()).toString();

System.out.println(str);

//输出Person{age=11}

8.强大的Ordering排序器

排序器[Ordering]是Guava流畅风格比较器[Comparator]的实现，它可以用来为构建复杂的比较器，以完成集合排序的功能。

natural()  对可排序类型做自然排序，如数字按大小，日期按先后排序

usingToString() 按对象的字符串形式做字典排序[lexicographical ordering]

from(Comparator)    把给定的Comparator转化为排序器

reverse()  获取语义相反的排序器

nullsFirst()    使用当前排序器，但额外把null值排到最前面。

nullsLast() 使用当前排序器，但额外把null值排到最后面。

compound(Comparator)    合成另一个比较器，以处理当前排序器中的相等情况。

lexicographical()  基于处理类型T的排序器，返回该类型的可迭代对象Iterable的排序器。

onResultOf(Function)    对集合中元素调用Function，再按返回值用当前排序器排序。

示例

Person person =newPerson("aa",14);//String name  ,Integer age

Person ps =newPerson("bb",13);

Ordering byOrdering = Ordering.natural().nullsFirst().onResultOf(newFunction(){

publicStringapply(Person person){

returnperson.age.toString();

    }

});

byOrdering.compare(person, ps);

System.out.println(byOrdering.compare(person, ps));//1      person的年龄比ps大 所以输出1

9.计算中间代码的运行时间

Stopwatch stopwatch = Stopwatch.createStarted();

for(inti=0; i<100000; i++){

// do some thing

}

longnanos = stopwatch.elapsed(TimeUnit.MILLISECONDS);

System.out.println(nanos);

TimeUnit 可以指定时间输出精确到多少时间

10.文件操作

以前我们写文件读取的时候要定义缓冲区，各种条件判断，各种$%#$@#

而现在我们只需要使用好guava的api 就能使代码变得简洁，并且不用担心因为写错逻辑而背锅了

File file =newFile("test.txt");

List list =null;

try{

    list = Files.readLines(file, Charsets.UTF_8);

}catch(Exception e) {

}

Files.copy(from,to);//复制文件

Files.deleteDirectoryContents(File directory);//删除文件夹下的内容(包括文件与子文件夹) 

Files.deleteRecursively(File file);//删除文件或者文件夹 

Files.move(File from, File to);//移动文件

URL url = Resources.getResource("abc.xml");//获取classpath根下的abc.xml文件url

Files类中还有许多方法可以用，可以多多翻阅

11.guava缓存

guava的缓存设计的比较巧妙，可以很精巧的使用。guava缓存创建分为两种，一种是CacheLoader,另一种则是callback方式

Cache的定时清理实现逻辑（失效时间+增加维护accessQueue,writeQueue两个队列用于记录缓存顺序，这样才可以按照顺序淘汰数据）：https://crossoverjie.top/2018/06/13/guava/guava-cache/

CacheLoader:

LoadingCache cahceBuilder=CacheBuilder

                .newBuilder()

// 设置并发级别，并发级别是指可以同时写缓存的线程数

.concurrencyLevel(10)

// 设置缓存过期时间

.expireAfterWrite(10, TimeUnit.MINUTES)

// 设置缓存容器的初始容量

.initialCapacity(10)

// 设置缓存最大容量，超过之后就会按照LRU最近虽少使用算法来移除缓存项

.maximumSize(500)

// 设置缓存的移除通知

.removalListener(newRemovalListener() {

publicvoidonRemoval(RemovalNotification notification){

LOGGER.warn(notification.getKey() +" was removed, cause is "+ notification.getCause());

                  }

                })

.build(newCacheLoader(){

@Override

publicStringload(String key)throwsException{

String strProValue="hello "+key+"!";

returnstrProValue;

                    }

                });       

System.out.println(cahceBuilder.apply("begincode"));//hello begincode!

System.out.println(cahceBuilder.get("begincode"));//hello begincode!

System.out.println(cahceBuilder.get("wen"));//hello wen!    //获取缓存值，callable实现缓存回调

System.out.println(cahceBuilder.apply("wen"));//hello wen!  //请求缓存值

System.out.println(cahceBuilder.apply("da"));//hello da!

cahceBuilder.put("begin","code");//设置缓存内容

System.out.println(cahceBuilder.get("begin"));//code

cahceBuilder.invalidateAll();//清除缓存

api中已经把apply声明为过期，声明中推荐使用get方法获取值

callback方式: 回调之中已经实现了对数据的添加，

Cache cache = CacheBuilder.newBuilder().maximumSize(1000).build();

String resultVal = cache.get("code",newCallable() {

publicStringcall(){

String strProValue="begin "+"code"+"!";//回调实现添加入值；无需put 

returnstrProValue;

    } 

}); 

System.out.println("value : "+ resultVal);//value : begin code!

//get回调实现源码

Vget(K key,inthash, CacheLoader loader)throwsExecutionException{

      checkNotNull(key);

      checkNotNull(loader);

try{

if(count !=0) {// read-volatile

// don't call getLiveEntry, which would ignore loading values

          ReferenceEntry e = getEntry(key, hash);

if(e !=null) {

longnow = map.ticker.read();

            V value = getLiveValue(e, now);

if(value !=null) {

              recordRead(e, now);

statsCounter.recordHits(1);

returnscheduleRefresh(e, key, hash, value, now, loader);

            }

            ValueReference valueReference = e.getValueReference();

if(valueReference.isLoading()) {

returnwaitForLoadingValue(e, key, valueReference);

            }

          }

        }

// 缓存中不存在数据

returnlockedGetOrLoad(key, hash, loader);

}catch(ExecutionException ee) {

        Throwable cause = ee.getCause();

if(causeinstanceofError) {

thrownewExecutionError((Error) cause);

}elseif(causeinstanceofRuntimeException) {

thrownewUncheckedExecutionException(cause);

        }

throwee;

}finally{

        postReadCleanup();

      }

    }

以上只是guava使用的一小部分，guava是个大的工具类，第一版guava是2010年发布的，每一版的更新和迭代都是一种创新。

jdk的升级很多都是借鉴guava里面的思想来进行的。

小结

代码可以在https://github.com/whirlys/elastic-example/tree/master/guava下载

细节请翻看 guava 文档https://github.com/google/guava/wiki