1、 Preconditions，前置条件判断
- 没有额外参数：抛出的异常中没有错误消息；
- 有一个Object对象作为额外参数：抛出的异常使用Object.toString() 作为错误消息；
- 有一个String对象作为额外参数，并且有一组任意数量的附加Object对象：这个变种处理异常消息的方式有点类似printf，但考虑GWT的兼容性和效率，只支持%s指示符。例如：
1 | checkArgument(i >= 0, "Argument was %s but expected nonnegative", i); |
2 | checkArgument(i < j, "Expected i < j, but %s > %s", i, j); |
| 方法声明（不包括额外参数） | 描述 | 检查失败时抛出的异常 |
| 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 |
equals：bjects.equal("a", "a"); // returns true
hashCode：Object.hashCode(Object ..)
compare:使用 ComparisonChain类：
实现一个比较器[Comparator]，或者直接实现Comparable接口有时也伤不起。考虑一下这种情况：
01 | class Person implements Comparable<Person> { |
02 | private String lastName; |
03 | private String firstName; |
04 | private int zipCode; |
05 |
06 | public int compareTo(Person other) { |
07 | int cmp = lastName.compareTo(other.lastName); |
08 | if (cmp != 0) { |
09 | return cmp; |
10 | } |
11 | cmp = firstName.compareTo(other.firstName); |
12 | if (cmp != 0) { |
13 | return cmp; |
14 | } |
15 | return Integer.compare(zipCode, other.zipCode); |
16 | } |
17 | } |
这部分代码太琐碎了，因此很容易搞乱，也很难调试。我们应该能把这种代码变得更优雅，为此，Guava提供了ComparisonChain。
ComparisonChain执行一种懒比较：它执行比较操作直至发现非零的结果，在那之后的比较输入将被忽略。
1 | public int compareTo(Foo that) { |
2 | return ComparisonChain.start() |
3 | .compare(this.aString, that.aString) |
4 | .compare(this.anInt, that.anInt) |
5 | .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast()) |
6 | .result(); |
7 | } |
链式调用方法：通过链式调用，可以由给定的排序器衍生出其它排序器
| 方法 | 描述 |
| reverse() | 获取语义相反的排序器 |
| nullsFirst() | 使用当前排序器，但额外把null值排到最前面。 |
| nullsLast() | 使用当前排序器，但额外把null值排到最后面。 |
| compound(Comparator) | 合成另一个比较器，以处理当前排序器中的相等情况。 |
| lexicographical() | 基于处理类型T的排序器，返回该类型的可迭代对象Iterable<T>的排序器。 |
| onResultOf(Function) | 对集合中元素调用Function，再按返回值用当前排序器排序。 |
例如，你需要下面这个类的排序器。
class Foo {
@Nullable String sortedBy;
int notSortedBy;
}
考虑到排序器应该能处理sortedBy为null的情况，我们可以使用下面的链式调用来合成排序器：
Ordering<Foo> ordering = Ordering.natural().nullsFirst().onResultOf(new Function<Foo, String>() {
public String apply(Foo foo) {
return foo.sortedBy;
}
});
当阅读链式调用产生的排序器时，应该从后往前读。上面的例子中，排序器首先调用apply方法获取sortedBy值，并把sortedBy为null的元素都放到最前面，然后把剩下的元素按sortedBy进行自然排序。之所以要从后往前读，是因为每次链式调用都是用后面的方法包装了前面的排序器。
注：用compound方法包装排序器时，就不应遵循从后往前读的原则。为了避免理解上的混乱，请不要把compound写在一长串链式调用的中间，你可以另起一行，在链中最先或最后调用compound。
超过一定长度的链式调用，也可能会带来阅读和理解上的难度。我们建议按下面的代码这样，在一个链中最多使用三个方法。此外，你也可以把Function分离成中间对象，让链式调用更简洁紧凑。
Ordering<Foo> ordering = Ordering.natural().nullsFirst().onResultOf(sortKeyFunction)大小写：CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "CONSTANT_NAME")); // returns "constantName"
字符集：不需要做异常处理：bytes = string.getBytes(Charsets.UTF_8);
collapseFrom(CharSequence, char):把每组连续的匹配字符替换为特定字符。如WHITESPACE.collapseFrom(string, ‘ ‘)把字符串中的连续空白字符替换为单个空格。
matchesAllOf(CharSequence): 测试是否字符序列中的所有字符都匹配。
removeFrom(CharSequence): 从字符序列中移除所有匹配字符。
retainFrom(CharSequence): 在字符序列中保留匹配字符，移除其他字符。
trimFrom(CharSequence): 移除字符序列的前导匹配字符和尾部匹配字符。
replaceFrom(CharSequence, CharSequence):用特定字符序列替代匹配字符
5、
可以简化集合的创建和初始化；
| 类别 | 原来的写法 | guava的写法 |
| 集合创建 | Map<String, Map<String, String>> map = new HashMap<String, Map<String,String>>(); List<List<Map<String, String>>> list = new ArrayList<List<Map<String,String>>>(); | Map<String, Map<String, String>> map = Maps.newHashMap(); List<List<Map<String, String>>> list = Lists.newArrayList(); //1,简化集合的创建 |
| 集合初始化 | Set<String> set = new HashSet<String>(); set.add("one"); set.add("two"); set.add("three"); | Set<String> set = Sets.newHashSet("one","two","three"); List<String> list = Lists.newArrayList("one","two","three"); Map<String, String> map = ImmutableMap.of("ON","TRUE","OFF","FALSE"); //2,简化集合的初始化 new Person(2, 1, "a", "46546", 1, 20)); new Person(2,1,"a","46546",1,20)); |
3.2 不变性
很大一部分是google集合提供了不变性，不变对比可变：
- 数据不可改变
- 线程安全
- 不需要同步逻辑
- 可以被自由的共享
- 容易设计和实现
- 内存和时间高效
不变对比不可修改
google的不变被确保真正不可改变，而不可修改实际上还是可以修改数据；如下所示：
Set<Integer> data = new HashSet<Integer>();
data.addAll(Arrays.asList(10, 20, 30, 40, 50, 60, 70, 80));
Set<Integer> fixedData = Collections.unmodifiableSet(data); // fixedData - [50, 70, 80, 20, 40, 10, 60, 30]
data.add(90); // fixedData - [50, 70, 80, 20, 40, 10, 90, 60, 30]
如何创建不可变的集合：
ImmutableSet<Integer> numbers = ImmutableSet.of(10, 20, 30, 40, 50);
使用copyOf方法
ImmutableSet<Integer> another = mmutableSet.copyOf(numbers);
使用Builder方法
ImmutableSet<Integer> numbers2 = ImmutableSet.<Integer>builder().addAll(numbers) .add(60) .add(70).add(80).build();
//3,创建不可变的集合
ImmutableList<Person> personImmutableList=
ImmutableList.of(new Person(1, 1, "a", "46546", 1, 20), new Person(2, 1, "a", "46546", 1, 20));
ImmutableSet<Person> personImmutableSet=ImmutableSet.copyOf(personSet2);
ImmutableMap<String,Person> personImmutableMap=ImmutableMap.<String,Person>builder()
.put("hell",new Person(1,1,"a","46546",1,20)).putAll(personMap2) .build();
3.3 新的集合类型
The Guava API provides very useful new collection types that work very nicely with existing java collections.
guava API 提供了有用的新的集合类型，协同已经存在的java集合工作的很好。
分别是 MultiMap， MultiSet， Table， BiMap， ClassToInstanceMap
| 种类 | 写的例子 |
| MultiMap | 一种key可以重复的map，子类有ListMultimap和SetMultimap，对应的通过key分别得到list和set
customersByType.put("abc", new Person(1, 1, "a", "46546", 1, 30)); for(Person person:customersByType.get("abc")) |
| MultiSet |
不是集合，可以增加重复的元素，并且可以统计出重复元素的个数，例子如下： private static void testMulitiSet() { System.out.println( multiSet.count(30)); // 2 |
| Table |
相当于有两个key的map，不多解释 private static void testTable() { //1,得到行集合 } |
| BiMap | 是一个一一映射，可以通过key得到value，也可以通过value得到key； private static void testBitMap() { biMap.put(1,"hello"); int value= biMap.inverse().get("my"); } |
| ClassToInstanceMap |
有的时候，你的map的key并不是一种类型，他们是很多类型，你想通过映射他们得到这种类型，guava提供了ClassToInstanceMap满足了这个目的。
除了继承自Map接口，ClassToInstaceMap提供了方法
T getInstance(Class<T>) 和
T putInstance(Class<T>, T),消除了强制类型转换。
该类有一个简单类型的参数，通常称为B，代表了map控制的上层绑定，例如：
ClassToInstanceMap<Number> numberDefaults = MutableClassToInstanceMap.create();
从技术上来说，
ClassToInstanceMap<B> 实现了
Map<Class<? extends B>, B>，或者说，这是一个从B的子类到B对象的映射，这可能使得
ClassToInstanceMap的泛型轻度混乱，但是只要记住B总是Map的上层绑定类型，通常来说B只是一个对象。
重点：像其他的Map<Class,Object>,
ClassToInstanceMap 含有的原生类型的项目，一个原生类型和他的相应的包装类可以映射到不同的值；
private static void testClass() { Person person= new Person(1,20,"abc","46464",1,100); classToInstanceMap.putInstance(Person.class,person);
Person person1=classToInstanceMap.getInstance(Person.class); } |
3.4 谓词和筛选
谓词（Predicate）是用来筛选集合的；
谓词是一个简单的接口，只有一个方法返回布尔值，但是他是一个很令人惊讶的集合方法，当你结合collections2.filter方法使用，这个筛选方法返回原来的集合中满足这个谓词接口的元素；
举个例子来说：筛选出集合中的女人
public static void main(String[] args)
{
Optional<ImmutableMultiset<Person>> optional=Optional.fromNullable(testPredict());
if(optional.isPresent())
{
for(Person p:optional.get())
{
System.out.println("女人："+p);
}
}
System.out.println(optional.isPresent());
}
public static ImmutableMultiset<Person> testPredict()
{
List<Person> personList=Lists.newArrayList(new Person(1, 1, "a", "46546", 1, 20),
new Person(2, 1, "ab", "46546", 0, 30),
new Person(3, 1, "abc", "46546", 0, 25),
new Person(4, 1, "aef", "46546", 1, 50),
new Person(5, 1, "ade", "46546",0, 27),
new Person(6, 1, "acc", "46546", 1, 29),
new Person(7, 1, "add", "46546",0, 33));
return ImmutableMultiset.copyOf(Collections2.filter(personList,new Predicate<Person>() {
@Override
public boolean apply( Person input) {
return input.getSex()==0;
}
}));
}
Predicates含有一些内置的筛选方法，比如说 in ,and ,not等，根据实际情况选择使用。
3.5 功能和转换
转换一个集合为另外一个集合；
实例如下：
public static void main(String[] args)
{
Optional<ImmutableMultiset<String>> optional=Optional.fromNullable(testTransform());
if(optional.isPresent())
{
for(String p:optional.get())
{
System.out.println("名字："+p);
}
}
System.out.println(optional.isPresent());
}
public static ImmutableMultiset<String> testTransform()
{
List<Person> personList=Lists.newArrayList(new Person(1, 1, "a", "46546", 1, 20),
new Person(2, 1, "ab", "46546", 0, 30),
new Person(3, 1, "abc", "46546", 0, 25),
new Person(4, 1, "aef", "46546", 1, 50),
new Person(5, 1, "ade", "46546",0, 27),
new Person(6, 1, "acc", "46546", 1, 29),
new Person(7, 1, "add", "46546",0, 33));
return ImmutableMultiset.copyOf(Lists.transform(personList,new Function<Person, String>() {
@Override
public String apply( Person input) {
return input.getName();
}
}));
}
3.6 排序
是guava一份非常灵活的比较类，可以被用来操作，扩展，当作比较器，排序提供了集合排序的很多控制；
实例如下：
Lists.newArrayList(30, 20, 60, 80, 10);
Ordering.natural().sortedCopy(numbers); //10,20,30,60,80
Ordering.natural().reverse().sortedCopy(numbers); //80,60,30,20,10
Ordering.natural().min(numbers); //10
Ordering.natural().max(numbers); //80
Lists.newArrayList(30, 20, 60, 80, null, 10);
Ordering.natural().nullsLast().sortedCopy(numbers); //10, 20,30,60,80,null
Ordering.natural().nullsFirst().sortedCopy(numbers); //null,10,20,30,60,80
public static void testOrdering()
{
List<Person> personList=Lists.newArrayList(
new Person(3, 1, "abc", "46546", 0, 25),
new Person(2, 1, "ab", "46546", 0, 30),
new Person(5, 1, "ade", "46546",0, 27),
new Person(1, 1, "a", "46546", 1, 20),
new Person(6, 1, "acc", "46546", 1, 29),
new Person(4, 1, "aef", "46546", 1, 50),
new Person(7, 1, "add", "46546",0, 33)
);
Ordering<Person> byAge=new Ordering<Person>() {
@Override
public int compare( Person left, Person right) {
return right.getAge()-left.getAge();
}
};
for(Person p: byAge.immutableSortedCopy(personList))
{
System.out.println(p);
}
}
扫一扫
2489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
