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

Hey 锡瑞

已于 2022-05-27 11:21:41 修改

阅读量1.2w

点赞数 8

分类专栏： Java 文章标签： java postman 开发语言

于 2020-08-08 15:55:00 首次发布

本文链接：https://blog.csdn.net/RuiKe1400360107/article/details/107879867

版权

Java 专栏收录该内容

24 篇文章 3 订阅

订阅专栏

一、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

可变集合接口	属于JDK还是Guava	不可变版本
Collection	JDK	ImmutableCollection
List	JDK	ImmutableList
Set	JDK	ImmutableSet
SortedSet/NavigableSet	JDK	ImmutableSortedSet
Map	JDK	ImmutableMap
SortedMap	JDK	ImmutableSortedMap
Multiset	Guava	ImmutableMultiset
SortedMultiset	Guava	ImmutableSortedMultiset
Multimap	Guava	ImmutableMultimap
ListMultimap	Guava	ImmutableListMultimap
SetMultimap	Guava	ImmutableSetMultimap
BiMap	Guava	ImmutableBiMap
ClassToInstanceMap	Guava	ImmutableClassToInstanceMap
Table	Guava	ImmutableTable

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

方法	描述
count(E)	给定元素在Multiset中的计数
elementSet()	Multiset中不重复元素的集合，类型为Set<E>
entrySet()	和Map的entrySet类似，返回Set<Multiset.Entry<E>>，其中包含的Entry支持getElement()和getCount()方法
add(E, int)	增加给定元素在Multiset中的计数
remove(E, int)	减少给定元素在Multiset中的计数
setCount(E, int)	设置给定元素在Multiset中的计数，不可以为负数
size()	返回集合元素的总个数（包括重复的元素）

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

Map	对应的Multiset	是否支持null元素
HashMap	HashMultiset	是
TreeMap	TreeMultiset	是（如果comparator支持的话）
LinkedHashMap	LinkedHashMultiset	是
ConcurrentHashMap	ConcurrentHashMultiset	否
ImmutableMap	ImmutableMultiset	否

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的方法有：

方法签名	描述	等价于
put(K, V)	添加键到单个值的映射	multimap.get(key).add(value)
putAll(K, Iterable<V>)	依次添加键到多个值的映射	Iterables.addAll(multimap.get(key), values)
remove(K, V)	移除键到值的映射；如果有这样的键值并成功移除，返回true。	multimap.get(key).remove(value)
removeAll(K)	清除键对应的所有值，返回的集合包含所有之前映射到K的值，但修改这个集合就不会影响Multimap了。	multimap.get(key).clear()
replaceValues(K, Iterable<V>)	清除键对应的所有值，并重新把key关联到Iterable中的每个元素。返回的集合包含所有之前映射到K的值。	multimap.get(key).clear(); Iterables.addAll(multimap.get(key), values)

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);  //创建父目录

参考：