包装
- 创建对象
构造 | 作用 |
---|---|
Optional.of(T) | 创建对象null 会报错 |
Optional.absent() | 缺省对象 |
Optional.fromNullable(T) | 创建对象 可以传 null |
Optional<Integer> op1 = Optional.of(null); // 异常 Optional<Integer> op2 = Optional.fromNullable(null); // 无异常
- 方法
方法 | 作用 |
---|---|
boolean isPresent() | 实体非null 判断 |
T get() | 获取实例 缺省异常 |
T or(T) | 获取实例 缺省默认 |
T orNull() | 获取实例 缺省回 null |
Set asSet() | set 封装缺省为空 |
- 实验
public class Null {
public static void main(String[] args) {
Optional<Integer> op = Optional.absent();
if(!op.isPresent()){
Integer or = op.or(99);
Integer orNull = op.orNull();
System.out.println("or : " + or);
System.out.println("orNull : " + orNull);
}else{
System.out.println("value : " + op.get());
}
}
}
字符
- 方法
方法(Strings ) | 作用 |
---|---|
String nullToEmpty(String string) | null 转"" |
String emptyToNull(String string) | "" 转null |
boolean isNullOrEmpty(String string) | 非"" 非null |
- 实验
public class Null {
public static void main(String[] args) {
String singleSpace = "";
String nullString = null;
String multiSpace = " ";
Arrays.asList(nullString,singleSpace,multiSpace).forEach((item)-> check(item));
}
public static void check(String sourceString){
System.out.println("***" + sourceString + "***");
System.out.println("emptyOrNull: " + Strings.isNullOrEmpty(sourceString) + ";");
System.out.println("empty2null : " + Strings.emptyToNull(sourceString) + ";");
System.out.println("null2empty : " + Strings.nullToEmpty(sourceString) + ";");
System.out.println("=================================================");
}
}
不会自动
trim
检查
- 方法
方法(Preconditions ) | 作用 |
---|---|
checkArgument(boolean) | 条件判断 |
checkNotNull(T) | 非null 判断 |
checkState(boolean) | 条件判断 |
checkElementIndex(int in dex, int size) | d e x ∈ ( 0 , s i z e ) dex\in{(0,size)} dex∈(0,size) |
checkPositionIndex(int index, int size) | i n d e x ∈ [ 0 , s i z e ) index\in{[0,size)} index∈[0,size) |
checkPositionIndexes(int start, int end, int size) | [ s t a r t , s i z e ] ∈ [ 0 , s i z e ] {[start,size]}\in[0,size] [start,size]∈[0,size] |
- 实验
public class Test {
public static void main(String[] args) {
Preconditions.checkArgument( 2 > 1);
Preconditions.checkState(5 > 3);
Preconditions.checkNotNull("");
Preconditions.checkElementIndex(3, 5);
Preconditions.checkPositionIndex(3, 5);
Preconditions.checkPositionIndexes(0,3,3);
}
}
不成立都会报错
Object
- 方法
方法 | 作用 |
---|---|
MoreObjects.toStringHelper().add()...toString | toString |
Objects.hashCode(Object ...) | hashCode |
ComparisonChain.start().compare(a,b)...result() | compareTo |
- 实验
class Person implements Comparable<Null.Person>{
public String name;
public Integer age;
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
.add("name", name)
.add("age", age)
.toString();
}
@Override
public int hashCode() {
return Objects.hashCode(name, age);
}
@Override
public int compareTo(Null.Person that) {
return ComparisonChain.start()
.compare(this.name, that.name)
.compare(this.age, that.age)
.result();
}
}
比较
构造
方式(Ordering ) | 解说 |
---|---|
natural | 自然排序 |
usingToString | 利用toString 返回值进行排序 |
from(Comparator) | 传入比较器进行构建 |
class MyOrdering extends Ordering<Integer>{
@Override
public int compare(Integer left, Integer right) {
return ComparisonChain.start().compare(left,right).result() ;
}
}
传入比较器的方法过时了,建议利用继承自己实现。
- 调整
调整 | 说明 |
---|---|
reverse | 反转排序规则 |
nullsFirst | 把null 排前面 |
nullsLast | 把null 排后面 |
compound(Comparator) | 出现相等情况采用指定比较器 |
lexicographical | 迭代器,还不懂 |
onResultOf(Function) | 操作之后,依据结果进行排序 |
- 施行
办法 | 效果 |
---|---|
greatestOf(Iterable iterable, int k) | 获取iterable 中最大的k 个元素 |
isOrdered(Iterable) | 是否有序 |
sortedCopy(Iterabl e) | 排序 |
min(Iterable) | 最小 |
max(Iterable) | 最大 |
- 实验
- 简单比较
System.out.println(Ordering.natural().compare(5,9));
- 排序
System.out.println(Ordering.natural().sortedCopy(Arrays.asList(1,3,5,7,9,2,4,6,8)));
- 大小
System.out.println(Ordering.natural().min(Arrays.asList(1,2,3,4,5,6,7,8,9))); System.out.println(Ordering.natural().max(Arrays.asList(1,2,3,4,5,6,7,8,9)));
- 结果
Ordering.natural() .onResultOf((Integer a)-> a % 2 == 0 ? a + 3 : a) .sortedCopy(Arrays.asList(1,2,3,4,5,6,7,8,9)) .forEach(item -> System.out.println("value : " + item + "\tresult: " + (item % 2 == 0 ? item + 3 : item)));
其中的
onResult
只是根据计算之后的结果进行了排序,返回的数据还是传入的原始数据。计算结果只是
排序依据
,是依据结果进行排序,而不是把结果排序输出。
异常
- 过滤
方法(Throwables ) | 用途 |
---|---|
propagateIfPossible | 匹配异常并抛出 |
throwIfInstanceOf | 匹配异常并抛出 |
public static void main(String[] args) {
try{
throw new NullPointerException("null");
}catch (Exception e){
Throwables.propagateIfPossible(e, NullPointerException.class);
}
}
如果没有异常,或者异常类型不匹配,就自动忽略。
try{ code... }catch(NullPointerException e){ throw e; }catch(ArrayIndexOutOfBoundsException e){ }catch(Exception e){ ... }
虽然
try...catch
不是不行,不过显然没有这个好用。反选还是好一点。
- 追踪
Throwables | 作用 |
---|---|
Throwable getRootCause(Throwable) | 根源问题 |
List getCausalChain(Throwable) | 层级链 |
String getStackTraceAsString(Throwable) | … |
public static void main(String[] args) {
try{
throw new NullPointerException("null");
}catch (Exception e){
Throwables.getCausalChain(e)
.forEach(item -> System.out.println(item.getMessage()));
}
}
不说多牛逼,不过更方便了就是。