guava-base

包装

  • 创建对象
构造作用
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()...toStringtoString
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反转排序规则
nullsFirstnull排前面
nullsLastnull排后面
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()));
        }
    }

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值