`包装`

创建对象

构造	作用
`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)`	$dex\in{(0,size)}$
`checkPositionIndex(int index, int size)`	$index\in{[0,size)}$
`checkPositionIndexes(int start, int end, int size)`	${[start,size]}\in[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()));
        }
    }

不说多牛逼，不过更方便了就是。

guava-base

`包装`

`字符`

`检查`

`Object`

`比较`

异常

猜你喜欢