Guava学习

学习下google的Guava包.

写几个demo试试.

github地址: guava

[TOC]

1, 基本工具 [Basic utilities]

1.1 使用和避免null:null是模棱两可的,会引起令人困惑的错误,有些时候它让人很不舒服。很多Guava工具类用快速失败拒绝null值,而不是盲目地接受

Optional最常用的一些操作被罗列如下:

创建Optional实例(以下都是静态方法):

方法 详细
Optional.of(T)) 创建指定引用的Optional实例,若引用为null则快速失败
Optional.absent()) 创建引用缺失的Optional实例
Optional.fromNullable(T)) 创建指定引用的Optional实例,若引用为null则表示缺失

用Optional实例查询引用(以下都是非静态方法):

方法 详细
boolean isPresent()) 如果Optional包含非null的引用(引用存在),返回true
T get()) 返回Optional所包含的引用,若引用缺失,则抛出java.lang.IllegalStateException
T or(T)) 返回Optional所包含的引用,若引用缺失,返回指定的值
T orNull()) 返回Optional所包含的引用,若引用缺失,返回null
Set asSet()) 返回Optional所包含引用的单例不可变集,如果引用存在,返回一个只有单一元素的集合,如果引用缺失,返回一个空集合。

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package p;

import static p.g.*;
import com.google.common.base.Optional;

import java.util.Iterator;
import java.util.Set;

public class C0010_Optional {
public static void main(String[] args) {
test1();
test2();
test3();
test4();
test5();
test6();
}

/**
* of.
*/

private static void test1() {
println("test1 start ------>");
Optional<Integer> possible = Optional.of(5); // 创建指定引用的Optional实例,若引用为null则快速失败
// Optional<Integer> possible = Optional.of(null); // 创建指定引用的Optional实例,若引用为null则快速失败
printOptionalValue(possible);
println("test1 end ------<");
}

/**
* absent.
*/

private static void test2() {
println("test2 start ------>");
Optional<Integer> possible = Optional.absent(); // 创建引用缺失的Optional实例
printOptionalValue(possible);
println("test2 end ------<");
}

/**
* fromNullable.
*/

private static void test3() {
println("test3 start ------>");
Integer n1 = null;
Integer n2 = 4;
Optional<Integer> possible1 = Optional.fromNullable(n1); // 创建指定引用的Optional实例,若引用为null则表示缺失
printOptionalValue(possible1);
Optional<Integer> possible2 = Optional.fromNullable(n2); // 创建指定引用的Optional实例,若引用为null则表示缺失
printOptionalValue(possible2);
println("test3 end ------<");
}

/**
* or.
*/

private static void test4() {
println("test4 start ------>");
Integer n1 = null;
Integer n2 = 5;
Optional<Integer> possible1 = Optional.fromNullable(n1); // 创建指定引用的Optional实例,若引用为null则表示缺失
Integer v1 = possible1.or(404); // 返回Optional所包含的引用,若引用缺失,返回指定的值
println(v1);
Optional<Integer> possible2 = Optional.fromNullable(n2); // 创建指定引用的Optional实例,若引用为null则表示缺失
Integer v2 = possible2.or(404); // 返回Optional所包含的引用,若引用缺失,返回指定的值
println(v2);
println("test4 end ------<");
}

/**
* orNull.
*/

private static void test5() {
println("test5 start ------>");
Integer n1 = null;
Integer n2 = 5;
Optional<Integer> possible1 = Optional.fromNullable(n1); // 创建指定引用的Optional实例,若引用为null则表示缺失
Integer v1 = possible1.orNull(); // 返回Optional所包含的引用,若引用缺失,返回null
println(v1);
Optional<Integer> possible2 = Optional.fromNullable(n2); // 创建指定引用的Optional实例,若引用为null则表示缺失
Integer v2 = possible2.orNull(); // 返回Optional所包含的引用,若引用缺失,返回null
println(v2);
println("test5 end ------<");
}

/**
* absent.
*/

private static void test6() {
println("test6 start ------>");
Optional<Integer> possible1 = Optional.absent(); // 创建引用缺失的Optional实例
final Set<Integer> integers1 = possible1.asSet(); // 返回Optional所包含引用的单例不可变集,如果引用存在,返回一个只有单一元素的集合,如果引用缺失,返回一个空集合。
println(integers1.size());

Optional<Integer> possible2 = Optional.of(5); // 创建引用缺失的Optional实例
final Set<Integer> integers2 = possible2.asSet(); // 返回Optional所包含引用的单例不可变集,如果引用存在,返回一个只有单一元素的集合,如果引用缺失,返回一个空集合。
Iterator<Integer> iterator2 = integers2.iterator();
println(integers2.size());

println("test6 end ------<");
}

private static void printOptionalValue(Optional<Integer> possible) {
if (possible.isPresent()) { // 如果Optional包含非null的引用(引用存在),返回true
int v = possible.get(); // 返回Optional所包含的引用,若引用缺失,则抛出java.lang.IllegalStateException
println(v);
} else {
println("可选值是空的");
}
}
}

1.2 前置条件: 让方法中的条件检查更简单

方法声明(不包括额外参数)** 描述** 检查失败时抛出的异常**
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
checkPositionIndex(int index, int size)) 检查index作为位置值对某个列表、字符串或数组是否有效。index>=0 && index<=size * IndexOutOfBoundsException
checkPositionIndexes(int start, int end, int size)) 检查[start, end]表示的位置范围对某个列表、字符串或数组是否有效* IndexOutOfBoundsException

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package p;

import static com.google.common.base.Preconditions.*;
import static p.g.*;

public class C0020_CheckArgument {
public static void main(String[] args) {
testCheckArgument(true, false);
testCheckNotNull("hello", null);
testCheckState(true, false);

testCheckElementIndex(-1, 2);
testCheckElementIndex(1, 2);
testCheckElementIndex(3, 2);

testCheckPositionIndex(-1, 2);
testCheckPositionIndex(1, 2);
testCheckPositionIndex(3, 2);

testCheckPositionIndexes(-1, 2, 5);
testCheckPositionIndexes(1, 2, 5);
testCheckPositionIndexes(1, 6, 5);
}

/**
* checkPositionIndexes(int start, int end, int size)
*/

private static void testCheckPositionIndexes(int start, int end, int size) {
println("testCheckPositionIndexes start ------>");
try {
checkPositionIndexes(start, end, size);
} catch (Exception e) {
println(e.getMessage());
}
println("testCheckPositionIndexes end ------<");
}

/**
* checkPositionIndex(int index, int size)
*/

private static void testCheckPositionIndex(int index, int size) {
println("testCheckPositionIndex start ------>");
try {
checkPositionIndex(index, size, "index error");
} catch (Exception e) {
println(e.getMessage());
}
println("testCheckPositionIndex end ------<");
}

/**
* checkElementIndex(int index, int size)
*/

private static void testCheckElementIndex(int index, int size) {
println("testCheckElementIndex start ------>");
try {
checkElementIndex(index, size, "index error");
} catch (Exception e) {
println(e.getMessage());
}
println("testCheckElementIndex end ------<");
}

/**
* checkState(boolean)
*/

private static void testCheckState(boolean v1, boolean v2) {
println("testCheckState start ------>");
try {
checkState(v1, "v1 true(v = %s)", v1);
checkState(v2, "v2 false(v = %s)", v2);
} catch (Exception e) {
println(e.getMessage());
}
println("testCheckState end ------<");
}

/**
* checkNotNull(T)
*/

private static void testCheckNotNull(String v1, String v2) {
println("testCheckArgument start ------>");
try {
checkNotNull(v1, "v1 not null(v = %s)", v1);
checkNotNull(v2, "v2 null(v = %s)", v2);
} catch (Exception e) {
println(e.getMessage());
}
println("testCheckArgument end ------<");
}

/**
* checkArgument(boolean)
*/

private static void testCheckArgument(boolean v1, boolean v2) {
println("testCheckArgument start ------>");
try {
checkArgument(v1, "v1 true(f = %s)", v1);
checkArgument(v2, "v2 false(f = %s)", v2);
} catch (Exception e) {
println(e.getMessage());
}
println("testCheckArgument end ------<");
}
}

1.3 常见Object方法: 简化Object方法实现,如hashCode()和toString()

// TODO

1.4 排序: Guava强大的”流畅风格比较器”

1.5 Throwables:简化了异常和错误的传播与检查

2, 集合[Collections]

3, 缓存[Caches]

4, 函数式风格[Functional idioms]

5, 并发[Concurrency]

6, 字符串处理[Strings]

7, 原生类型[Primitives]

8, 区间[Ranges]

9, I/O

10, 散列[Hash]

11, 事件总线[EventBus]

12, 数学运算[Math]

13, 反射[Reflection]

参考文章

Fork me on GitHub