2018-10-29

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

高效设计良好的API，被Google的开发者设计，实现和使用
遵循高效的java语法实践
使代码更刻度，简洁，简单
节约时间，资源，提高生产力
Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：

集合 [collections]
缓存 [caching]
原生类型支持 [primitives support]
并发库 [concurrency libraries]
通用注解 [common annotations]
字符串处理 [string processing]
I/O 等等。

使用
引入maven依赖(就是引入jar包)

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>27.0-jre</version>
</dependency>

1. 集合的创建

//普通Collection创建，和原来方法区别不大
List<String> list = Lists.newArrayList();
HashSet<String> set = Sets.newHashSet();
HashMap<Object, Object> map = Maps.newHashMap();
//不可变Collection,实现了原来的接口
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");

不可变类有什么用:
1.在多线程操作下，是线程安全的。
2.所有不可变集合会比可变集合更有效的利用资源。
3.中途不可改变

Map中的value为List的时候，新旧写法对比。

//旧写法
HashMap<String, List<Integer>> hashMap = new HashMap<>();
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
hashMap.put("aaa", list);
System.out.println(hashMap);//{aaa=[1, 2]}

//新写法
Multimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put("aaa", 1);
multimap.put("aaa", 2);
System.out.println(multimap);//{aaa=[1, 2]}

其他集合

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();

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

List转字符串，并且添加连接符，新旧方法对比

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
String string = new String();
for (String str : list) {
    string += "," + str;
}
System.out.println("string:" + string.substring(1));//string:a,b,c

Lists.newArrayList("a", "b", "c");
String string1 = Joiner.on(",").join(list);
System.out.println("string1:" + string1);//string1:a,b,c

Map按照特定格式输出字符串

Map<String, Integer> map = Maps.newHashMap();
map.put("小明", 20);
map.put("小红", 23);
String string = Joiner.on("、").withKeyValueSeparator("=>").join(map);
System.out.println(string);//小明=>20、小红=>23

将String转换为List，新旧方法对比

String string = "a,b,c,d,e,f";
String[] strings = string.split(",");
List<String> list = Lists.newArrayList();
for (String str : strings) {
    list.add(str);
}
System.out.println(list);//[a, b, c, d, e, f]

List<String> list2 = Splitter.on(",").splitToList(string);
System.out.println(list2);//[a, b, c, d, e, f]

特殊格式字符串，omitEmptyStrings()可以去除空字符串，trimResults()可以去除分割后的字符串前后的空格

String str = "1,2,3,4,  5,  6  , ";
List<String> list = Splitter.on(",").omitEmptyStrings().trimResults().splitToList(str);
List<String> list1 = Splitter.on(",").splitToList(str);
System.out.println(list);//[1, 2, 3, 4, 5, 6]
System.out.println(list1);//[1, 2, 3, 4,   5,   6  ,  ]

将String转为Map

String str = "小明=20,小红=23";
Map<String, String> map = Splitter.on(",").withKeyValueSeparator("=").split(str);
System.out.println(map);//{小明=20, 小红=23}

正则分割

String input = "aa.dd,,ff,,.";
List<String> result = Splitter.onPattern("[.|,]").omitEmptyStrings().splitToList(input);
System.out.println(result);//[aa, dd, ff]

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

// 判断匹配结果
boolean result = CharMatcher.inRange('a', 'z').or(CharMatcher.inRange('A', 'Z')).matches('2'); //true
// 保留数字文本
String s1 = CharMatcher.digit().retainFrom("abc 123 efg"); //123
// 删除数字文本
String s2 = CharMatcher.digit().removeFrom("abc 123 efg");    //abc  efg

集合的过滤
我们对集合的操作，一般都是循环遍历集合，然后对其中的属性进行操作。

//按照条件过滤
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]

//自定义过滤条件   使用自定义回调方法对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}

set的交集, 并集, 差集

Set setA = Sets.newHashSet(1, 2, 3, 4, 5);
Set setB = Sets.newHashSet(4, 5, 6, 7, 8);

//A并B
Set union = Sets.union(setA, setB);
System.out.println(union);//[1, 2, 3, 4, 5, 8, 6, 7]

//A差B
Set difference = Sets.difference(setA, setB);
System.out.println(difference);//[1, 2, 3]

//A交B
Set intersection = Sets.intersection(setA, setB);
System.out.println(intersection);//[4, 5]

map的交集，并集，差集（没测试）

MapDifference differenceMap = Maps.difference(mapA, mapB);  
differenceMap.areEqual();  
Map entriesDiffering = differenceMap.entriesDiffering();  
Map entriesOnlyOnLeft = differenceMap.entriesOnlyOnLeft();  
Map entriesOnlyOnRight = differenceMap.entriesOnlyOnRight();  
Map entriesInCommon = differenceMap.entriesInCommon();  

参数检查

List list = Lists.newArrayList();
String str = new String();
//use java
Boolean boolean1 = (list != null && list.size() > 0);
Boolean boolean2 = (str != null && str.length() > 0);
Boolean boolean3 = (str != null && !str.isEmpty());

//use guava
Boolean boolean4 = CollectionUtils.isEmpty(list);//替代boolean1和boolean2
Boolean boolean5 = StringUtils.isNotEmpty(str);//替代boolean3

//use java
int count = 0;
if (count <= 0) {
    throw new IllegalArgumentException("must be positive: " + count);
}

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

checkNotNull在检查对象为空时抛出空指针

@CanIgnoreReturnValue
public static <T> T checkNotNull(T reference) {
    if (reference == null) {
      throw new NullPointerException();
    }
    return reference;
}