Java系列6：Google工具包Guava的使用（看这一篇就够了）_google java工具包

一、Guava工具包简介

（1）简介：略

（2）使用前引入maven依赖

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

二、集合

2.1、不可变集合ImmutableXXX

（1）普通的Collection集合创建

List<String> list = Lists.newArrayList();
Set<String> set = Sets.newHashSet();
Map<String, String> map = Maps.newHashMap();

（2）不可变集合创建

备注：用不变的集合进行防御性编程和性能提升

JDK也提供了Collections.unmodifiableXXX方法把集合包装为不可变形式，但不够好

不可变集合可以用如下多种方式创建：

1、copyOf方法：

如ImmutableSet.copyOf(set);

2、of方法，

如ImmutableSet.of(“a”, “b”, “c”)或 ImmutableMap.of(“a”, 1, “b”, 2)；

ImmutableList<String> iList = ImmutableList.of("a", "b", "c");
ImmutableSet<String> iSet = ImmutableSet.of("e1", "e2");
ImmutableMap<String, String> iMap = ImmutableMap.of("k1", "v1", "k2", "v2");

 3、Builder工具：

public static final ImmutableSet<Color> GOOGLE_COLORS =
        ImmutableSet.<Color>builder()
            .addAll(WEBSAFE_COLORS)
            .add(new Color(0, 191, 255))
            .build();

不可变集合优点:

• 在多线程操作下，是线程安全的。
• 所有不可变集合会比可变集合更有效的利用资源。
• 中途不可改变。
• 当对象被不可信的库调用时，不可变形式是安全的。
• 不可变集合不需要考虑变化，因此可以节省时间和空间。
• 不可变对象因为有固定不变，可以作为常量来安全使用。

参考中文官网：[Google Guava] 2.1-不可变集合 | 并发编程网 – ifeve.com

2.2、新型集合（ multisets, multimaps, tables, bidirectional maps）

（1）Multiset

作用：可以多次添加相等的元素，Multiset元素的顺序是无关紧要的：Multiset {a, a, b}和{a, b, a}是相等的

类似：

• 没有元素顺序限制的ArrayList<E> 。     当把Multiset看成普通的Collection时，它表现得就像无序的ArrayList

add(E)添加单个给定元素
iterator()返回一个迭代器，包含Multiset的所有元素（包括重复的元素）
size()返回所有元素的总个数（包括重复的元素）

• Map<E, Integer>，键为元素，值为计数   。当把Multiset看作Map<E, Integer>时，它也提供了符合性能期望的查询操作

count(Object)返回给定元素的计数。HashMultiset.count的复杂度为O(1)，TreeMultiset.count的复杂度为O(log n)。
entrySet()返回Set<Multiset.Entry<E>>，和Map的entrySet类似。
elementSet()返回所有不重复元素的Set<E>，和Map的keySet()类似。
所有Multiset实现的内存消耗随着不重复元素的个数线性增长。

注意：

• TreeMultiset在判断元素是否相等时，与TreeSet一样用compare，而不是Object.equals
• Multiset.addAll(Collection)可以添加Collection中的所有元素并进行计数，这比用for循环往Map添加元素和计数方便多了
• Multiset不是Map，是一种Collection类型

（1）Multiset中的元素计数只能是正数。任何元素的计数都不能为负，也不能是0。elementSet()和entrySet()视图中也不会有这样的元素。
（2）multiset.size()返回集合的大小，等同于所有元素计数的总和。对于不重复元素的个数，应使用
elementSet().size()方法。（因此，add(E)把multiset.size()增加1）
（3）multiset.iterator()会迭代重复元素，因此迭代长度等于multiset.size()。
（4）Multiset支持直接增加、减少或设置元素的计数。setCount(elem, 0)等同于移除所有elem。
对multiset 中没有的元素，multiset.count(elem)始终返回0

方法:

参考：[Google Guava] 2.2-新集合类型 | 并发编程网 – ifeve.com

Multiset的各种实现，对应Map的实现：

SortedMultiset： 

是Multiset 接口的变种，它支持高效地获取指定范围的子集。比如，可以用 latencies.subMultiset(0,BoundType.CLOSED, 100, BoundType.OPEN).size()来统计你的站点中延迟在100毫秒以内的访问，然后把这个值和latencies.size()相比，以获取这个延迟水平在总体访问中的比例

（2）Multimap用法

注意：很少会直接使用Multimap接口，更多时候你会用ListMultimap或SetMultimap接口，它们分别把键映射到List或Set。ListMultimap.get(key)返回List，SetMultimap.get(key)返回Set

使用场景：Map<K, List<V>>或Map<K, Set<V>>

案例1：当我们需要一个map中包含key为String类型，value为List类型的时候

普通写法：

1. Map<String,List<Integer>> map = new HashMap<String,List<Integer>>();
2. List<Integer> list = new ArrayList<Integer>();
3. list.add(1);
4. list.add(2);
5. map.put("test", list);
   System.out.println(map.get("test"));
#需要5步，执行结果[1, 2]

 Multimap写法：

1. Multimap<String,Integer> mapM = ArrayListMultimap.create();
2. mapM.put("test",1);
3. mapM.put("test",2);
   System.out.println(mapM.get("test"));
#需要3步，执行结果[1, 2]

修改Multimap的方法有：

2.3、其余常见集合

MultiSet: 无序+可重复   count()方法获取单词的次数  增强了可读性+操作简单
创建方式:  Multiset<String> set = HashMultiset.create();
 
Multimap: key-value  key可以重复  
创建方式: Multimap<String, String> teachers = ArrayListMultimap.create();
 
BiMap: 双向Map(Bidirectional Map) 键与值都不能重复
创建方式:  BiMap<String, String> biMap = HashBiMap.create();
 
Table: 双键的Map Map--> Table-->rowKey+columnKey+value  //和sql中的联合主键有点像
创建方式: Table<String, String, Integer> tables = HashBasedTable.create();

 2.4、集合的过滤

（1）按照条件过滤

ImmutableList<String> names = ImmutableList.of("begin", "code", "Guava", "Java");
Iterable<String> fitered = Iterables.filter(names, Predicates.or(Predicates.equalTo("Guava"), Predicates.equalTo("Java")));
System.out.println(fitered); // [Guava, Java]

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

ImmutableMap<String, Integer> m = ImmutableMap.of("begin", 12, "code", 15);
        // Function<F, T> F表示apply()方法input的类型，T表示apply()方法返回类型
        Map<String, Integer> m2 = Maps.transformValues(m, new Function<Integer, Integer>() {
            public Integer apply(Integer input) {
                if(input>12){
                    return input;
                }else{
                    return input+1;
                }
            }
        });
System.out.println(m2);   //{begin=13, code=15}

2.5、集合的交集, 并集, 差集 

（1）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

（2）map集合

HashMap<String, Integer> mapA = Maps.newHashMap();
mapA.put("a", 1);mapA.put("b", 2);mapA.put("c", 3);
 
HashMap<String, Integer> 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}

三、字符串

3.1、串连接器Joiner

（1）连接多个字符串并追加到StringBuilder：

StringBuilder stringBuilder = new StringBuilder("嗨，");
// 字符串连接器，以|为分隔符，同时去掉null元素
Joiner joiner1 = Joiner.on("|").skipNulls();
// 构成一个字符串jim|jack|kevin并添加到stringBuilder
stringBuilder = joiner1.appendTo(stringBuilder, "jim", "jack", null, "kevin");
System.out.println(stringBuilder); 
//执行结果：  嗨，jim|jack|kevin

（2）将Map转化为字符串

Map<String, String> testMap = Maps.newLinkedHashMap();
        testMap.put("Cookies", "12332");
        testMap.put("Content-Length", "30000");
        testMap.put("Date", "2018.07.04");
        testMap.put("Mime", "text/html");
        // 用:分割键值对，并用#分割每个元素，返回字符串
        String returnedString = Joiner.on("#").withKeyValueSeparator(":").join(testMap);
        System.out.println(returnedString);
        // 执行结果：Cookies:12332#Content-Length:30000#Date:2018.07.04#Mime:text/html

3.2、Strings：字符串工具类

（1）判断

System.out.println(Strings.isNullOrEmpty("")); // true
System.out.println(Strings.isNullOrEmpty(null)); // true
System.out.println(Strings.isNullOrEmpty("hello")); // false

（2）将null转化为""

System.out.println(Strings.nullToEmpty(null)); // ""

（3）填充

例如：从尾部不断补充T只到总共8个字符，如果源字符串已经达到或操作，则原样返回。

System.out.println(Strings.padEnd("hello", 8, 'T')); // helloTTT

3.3、CharMatcher：字符匹配器

（1）空白替换

// 空白回车换行对应换成一个#，一对一换
String stringWithLinebreaks = "hello world\r\r\ryou are here\n\ntake it\t\t\teasy";
String s6 = CharMatcher.BREAKING_WHITESPACE.replaceFrom(stringWithLinebreaks,'#');
System.out.println(s6); 
// 执行结果：hello#world###you#are#here##take#it###easy

（2）连续空白缩成一个字符

// 将所有连在一起的空白回车换行字符换成一个#，倒塌
String tabString = "  hello   \n\t\tworld   you\r\nare             here  ";
String tabRet = CharMatcher.WHITESPACE.collapseFrom(tabString, '#');
System.out.println(tabRet); 
// 执行结果： #hello#world#you#are#here#

（3）去掉前后空白和缩成一个字符

// 在前面的基础上去掉字符串的前后空白，并将空白换成一个#
String trimRet = CharMatcher.WHITESPACE.trimAndCollapseFrom(tabString, '#');
System.out.println(trimRet);
// 执行结果： hello#world#you#are#here

（4）只保留数字，去掉其余字符

String letterAndNumber = "1234abcdABCD56789";
// 保留数字
String number = CharMatcher.JAVA_DIGIT.retainFrom(letterAndNumber);
System.out.println(number);
// 执行结果：123456789

四、Ordering排序器

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

natural()   对可排序类型做自然排序，如数字按大小，日期按先后排序
usingToString() 按对象的字符串形式做字典排序[lexicographical ordering]
from(Comparator)    把给定的Comparator转化为排序器
reverse()   获取语义相反的排序器
nullsFirst()    使用当前排序器，但额外把null值排到最前面。
nullsLast() 使用当前排序器，但额外把null值排到最后面。
compound(Comparator)    合成另一个比较器，以处理当前排序器中的相等情况。
lexicographical()   基于处理类型T的排序器，返回该类型的可迭代对象Iterable<T>的排序器。
onResultOf(Function)    对集合中元素调用Function，再按返回值用当前排序器排序。

示例1：

Person person = new Person("aa",14);  //String name  ,Integer age
Person ps = new Person("bb",13);
Ordering<Person> byOrdering = Ordering.natural().nullsFirst().onResultOf(new Function<Person,String>(){
    public String apply(Person person){
        return person.age.toString();
    }
});
byOrdering.compare(person, ps);
System.out.println(byOrdering.compare(person, ps)); //1      person的年龄比ps大 所以输出1

五、文件操作

5.1、Files类

以前我们写文件读取的时候要定义缓冲区，各种条件判断，只需要使用好guava的api 就能使代码变得简洁

File file = new File("test.txt");
List<String> 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.copy(from,to);  //复制文件 Path path = Paths.get("C:\\Users\\EX-LIFANGTAO001\\IdeaProjects\\Test001\\spring-boot-starter-hello\\src\\main\\resources\\abc\\123\\78");MoreFiles.deleteDirectoryContents(path, RecursiveDeleteOption.ALLOW_INSECURE); //删除文件夹下的内容(包括文件与子文件夹)MoreFiles.deleteRecursively(File file); //删除文件或者文件夹 MoreFiles.createParentDirectories(path);  //创建父目录

  参考：

Guva官方文档：

英文：https://github.com/google/guava/wiki

中文1：Google Guava官方教程（中文版） | 并发编程网 – ifeve.com

中文2：Google Guava官方教程（中文版） | Google Guava 中文教程

若对你有帮助，欢迎关注！！点赞！！评论！！