概述
工具類 就是封裝平常用的方法，不需要你重復造輪子，節省開發人員時間，提高工作效率。谷歌作為大公司，當然會從日常的工作中提取中很多高效率的方法出來。所以就誕生了guava。。
- 高效設計良好的API，被Google的開發者設計，實現和使用
- 遵循高效的java語法實踐
- 使代碼更刻度，簡潔，簡單
- 節約時間，資源，提高生產力 Guava工程包含了若干被Google的 Java項目廣泛依賴 的核心庫，例如：
- 集合 [collections]
- 緩存 [caching]
- 原生類型支持 [primitives support]
- 並發庫 [concurrency libraries]
- 通用注解 [common annotations]
- 字符串處理 [string processing]
- I/O 等等。
使用
引入maven依賴(就是引入jar包)
(從版本號就能看出 guava是一步步改進的，並且跟隨的jdk不斷的提取其中優秀的部分)
|
1
2
3
4
5
6
7
|
'''
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>20.0</version>
</dependency>
'''
|
1.集合的創建
|
1
2
3
4
5
6
7
8
9
|
// 普通Collection的創建
List<String> list = Lists.newArrayList();
Set<String> set = Sets.newHashSet();
Map<String, String> 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");
|
創建不可變集合
先理解什么是immutable(不可變)對象1.在多線程操作下，是線程安全的。
2.所有不可變集合會比可變集合更有效的利用資源。
3.中途不可改變
這句話就聲明了一個不可變的list集合，里面有數據1，2，3，4。方法中的==操作集合的方法都聲明過期==，並且拋出異常。
沒用guava之前是需要聲明並且加各種包裹集合才能實現這個功能。
當我們需要一個map中包含key為String value為List類型的時候 以前我們是這樣寫的
|
1
2
3
4
5
6
|
Map<String,List<Integer>> map = new HashMap<String,List<Integer>>();
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
map.put("aa", list);
System.out.println(map.get("aa"));//[1, 2]
|
而現在
|
1
2
3
4
|
Multimap<String,Integer> map = ArrayListMultimap.create();
map.put("aa", 1);
map.put("aa", 2);
System.out.println(map.get("aa")); //[1, 2]
|
其他的黑科技集合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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里面沒有給出的集合類型)
|
2.將集合轉換為特定規則的字符串
以前我們將list轉換為特定規則的字符串是這樣寫的:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
//use java
List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
String str = "";
for(int i=0; i<list.size(); i++){
str = str + "-" +list.get(i);
}
//str 為-aa-bb-cc
//use guava
List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
String result = Joiner.on("-").join(list);
//result為 aa-bb-cc
|
把map集合轉換為特定規則的字符串
|
1
2
3
4
5
|
Map<String, Integer> map = Maps.newHashMap();
map.put("xiaoming", 12);
map.put("xiaohong",13);
String result = Joiner.on(",").withKeyValueSeparator("=").join(map);
// result為 xiaoming=12,xiaohong=13
|
3.將String轉換為特定的集合
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//use java
List<String> list = new ArrayList<String>();
String a = "1-2-3-4-5-6";
String[] strs = a.split("-");
for(int i=0; i<strs.length; i++){
list.add(strs[i]);
}
//use guava
String str = "1-2-3-4-5-6";
List<String> list = Splitter.on("-").splitToList(str);
//list為 [1, 2, 3, 4, 5, 6]
|
如果
|
1
|
str="1-2-3-4- 5- 6 ";
|
guava還可以使用
==使用 “-“ 切分字符串並去除空串與空格== omitEmptyStrings().trimResults() 去除空串與空格
就能忽略中間的空格
將String轉換為map
|
1
2
|
String str = "xiaoming=11,xiaohong=23";
Map<String,String> map = Splitter.on(",").withKeyValueSeparator("=").split(str);
|
4.guava還支持多個字符切割，或者特定的正則分隔
|
1
2
|
String input = "aa.dd,,ff,,.";
List<String> result = Splitter.onPattern("[.|,]").omitEmptyStrings().splitToList(input);
|
==關於字符串的操作 都是在Splitter這個類上進行的。==
|
1
2
3
4
5
6
|
// 判斷匹配結果
boolean result = CharMatcher.inRange('a', 'z').or(CharMatcher.inRange('A', 'Z')).matches('K'); //true
// 保留數字文本
String s1 = CharMatcher.digit().retainFrom("abc 123 efg"); //123
// 刪除數字文本
String s2 = CharMatcher.digit().removeFrom("abc 123 efg"); //abc efg
|
5. 集合的過濾
我們對於集合的過濾，思路就是迭代，然后再具體對每一個數判斷，這樣的代碼放在程序中，難免會顯得很臃腫，雖然功能都有，但是很不好看。
guava寫法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
//按照條件過濾
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的交集, 並集, 差集
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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的交集，並集，差集
|
1
2
3
4
5
6
|
MapDifference differenceMap = Maps.difference(mapA, mapB);
differenceMap.areEqual();
Map entriesDiffering = differenceMap.entriesDiffering();
Map entriesOnlyOnLeft = differenceMap.entriesOnlyOnLeft();
Map entriesOnlyOnRight = differenceMap.entriesOnlyOnRight();
Map entriesInCommon = differenceMap.entriesInCommon();
|
6.檢查參數
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
//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) {
throw new IllegalArgumentException("must be positive: " + count);
}
//use guava
Preconditions.checkArgument(count > 0, "must be positive: %s", count);
|
免去了很多麻煩！並且會使你的代碼看上去更好看。而不是代碼里面充斥着!=null， !=””
(問答系統源碼里面有很多這種代碼，后一版得抓緊改掉。。)
檢查是否為空,不僅僅是字符串類型，其他類型的判斷 全部都封裝在 Preconditions類里 里面的方法全為靜態。
其中的一個方法的源碼
|
1
2
3
4
5
6
7
|
@CanIgnoreReturnValue
public static <T> T checkNotNull(T reference) {
if (reference == null) {
throw new NullPointerException();
}
return reference;
}
|
| 方法聲明（不包括額外參數） | 描述 | 檢查失敗時拋出的異常 |
|---|---|---|
| checkArgument(boolean) | 檢查boolean是否為true，用來檢查傳遞給方法的參數。 | IllegalArgumentException |
| checkNotNull(T) | 檢查value是否為null，該方法直接返回value，因此可以內嵌使用checkNotNull。 | NullPointerException |
| checkState(boolean) | 用來檢查對象的某些狀態。 | IllegalStateException |
| checkElementIndex(int index, int size) | 檢查index作為索引值對某個列表、字符串或數組是否有效。index>=0 && index<size * | IndexOutOfBoundsException |
| checkPositionIndexes(int start, int end, int size) | 檢查[start, end]表示的位置范圍對某個列表、字符串或數組是否有效* | IndexOutOfBoundsException |
7.MoreObjects
這個方法是在Objects過期后 官方推薦使用的替代品，該類最大的好處就是不用大量的重寫toString，用一種很優雅的方式實現重寫，或者在某個場景定制使用。
|
1
2
3
4
|
Person person = new Person("aa",11);
String str = MoreObjects.toStringHelper("Person").add("age", person.getAge()).toString();
System.out.println(str);
//輸出Person{age=11}
|
8.強大的Ordering排序器
排序器[Ordering]是Guava流暢風格比較器[Comparator]的實現，它可以用來為構建復雜的比較器，以完成集合排序的功能。
|
1
2
3
4
5
6
7
8
9
|
natural() 對可排序類型做自然排序，如數字按大小，日期按先后排序
usingToString() 按對象的字符串形式做字典排序[lexicographical ordering]
from(Comparator) 把給定的Comparator轉化為排序器
reverse() 獲取語義相反的排序器
nullsFirst() 使用當前排序器，但額外把null值排到最前面。
nullsLast() 使用當前排序器，但額外把null值排到最后面。
compound(Comparator) 合成另一個比較器，以處理當前排序器中的相等情況。
lexicographical() 基於處理類型T的排序器，返回該類型的可迭代對象Iterable<T>的排序器。
onResultOf(Function) 對集合中元素調用Function，再按返回值用當前排序器排序。
|
|
1
2
3
4
5
6
7
8
9
|
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
|
9.計算中間代碼的運行時間
|
1
2
3
4
5
6
|
Stopwatch stopwatch = Stopwatch.createStarted();
for(int i=0; i<100000; i++){
}
long nanos = stopwatch.elapsed(TimeUnit.MILLISECONDS);
System.out.println(nanos);
|
TimeUnit 可以指定時間輸出精確到多少時間
10.文件操作
以前我們寫文件讀取的時候要定義緩沖區，各種條件判斷，各種$%#$@#
而現在我們只需要使用好guava的api 就能使代碼變得簡潔，並且不用擔心因為寫錯邏輯而背鍋了
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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類中還有許多方法可以用，可以多多翻閱。
11.guava緩存
guava的緩存設計的比較巧妙，可以很精巧的使用。guava緩存創建分為兩種，一種是CacheLoader,另一種則是callback方式
CacheLoader:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
LoadingCache<String,String> cahceBuilder=CacheBuilder
.newBuilder()
.build(new CacheLoader<String, String>(){
@Override
public String load(String key) throws Exception {
String strProValue="hello "+key+"!";
return strProValue;
}
});
System.out.println(cahceBuilder.apply("begincode")); //hello begincode!
System.out.println(cahceBuilder.get("begincode")); //hello begincode!
System.out.println(cahceBuilder.get("wen")); //hello wen!
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
|
api中已經把apply聲明為過期，聲明中推薦使用get方法獲取值
callback方式:
|
1
2
3
4
5
6
7
8
|
Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(1000).build();
String resultVal = cache.get("code", new Callable<String>() {
public String call() {
String strProValue="begin "+"code"+"!";
return strProValue;
}
});
System.out.println("value : " + resultVal); //value : begin code!
|
以上只是guava使用的一小部分，guava是個大的工具類，第一版guava是2010年發布的，每一版的更新和迭代都是一種創新。
jdk的升級很多都是借鑒guava里面的思想來進行的。
以上可能會有錯誤或者表意不全的地方，歡迎評論指出。
(歡迎加qq群:5369686 ) 只討論技術 不閑聊 .