guava(二) Equivalence & Supplier

一、Equivalence 

一种判定两个实例是否相等的策略

全路径:

com.google.common.base

声明:

@GwtCompatible

public abstract class Equivalence<T>

核心方法

equivalent()

public final boolean equivalent(@Nullable T a, @Nullable T b) {
    if (a == b) {
      return true;
    }
    if (a == null || b == null) {
      return false;
    }
    return doEquivalent(a, b);
  }

Equivalence<F> onResultOf(Function<F, ? extends T> function) 先计算funcion,在比较

boolean result = Equivalence.equals().onResultOf(new Function<Object, Object>() {
            @Override
            public Object apply(Object input) {
                return null;
            }
        }).equivalent(1, 2);

Predicate<T> equivalentTo(@Nullable T target) 转成predicate

Map<String,Integer> result=Maps.filterKeys(ImmutableMap.of("a",1,"b",2),Equivalence.equals().equivalentTo("a"));

 

静态内部类 Equals(如其名,判断内容是否相等)

声明:

static final class Equals extends Equivalence<Object> implements Serializable

重写 doEquivalent

 @Override
    protected boolean doEquivalent(Object a, Object b) {
      return a.equals(b);
    }

获得Equals实例

Equivalence.equals()

举个例子

 String s="abc";
 String s1=new String("abc");
 System.out.println(Equivalence.equals().equivalent(s,s1));//true

 

静态内部类 Identity (如其名,判断内存地址是否唯一)

声明:

static final class Identity extends Equivalence<Object> implements Serializable

重写 doEquivalent

 @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

获得Equals实例

Equivalence.identity()

举个例子

  String s="abc";
  String s1=new String("abc");
  System.out.println(Equivalence.identity().equivalent(s,s1)); //false

 

子类 FunctionalEquivalence 

声明:

final class FunctionalEquivalence<F, T> extends Equivalence<F> implements Serializabl

构造函数:

FunctionalEquivalence(Function<F, ? extends T> function, Equivalence<T> resultEquivalence) {
    this.function = checkNotNull(function);
    this.resultEquivalence = checkNotNull(resultEquivalence);
  }

重写 doEquivalent

 @Override
  protected boolean doEquivalent(F a, F b) {
    return resultEquivalence.equivalent(function.apply(a), function.apply(b));
  }

举个例子

看起来是经过function处理后,判断相等关系。default修饰符,暂时没看懂怎么使用 - -

子类 PairwiseEquivalence

声明:

final class PairwiseEquivalence<T> extends Equivalence<Iterable<T>> implements Serializable

构造函数

 PairwiseEquivalence(Equivalence<? super T> elementEquivalence) {
    this.elementEquivalence = Preconditions.checkNotNull(elementEquivalence);
  }

重写 doEquivalent

 @Override
  protected boolean doEquivalent(Iterable<T> iterableA, Iterable<T> iterableB) {
    Iterator<T> iteratorA = iterableA.iterator();
    Iterator<T> iteratorB = iterableB.iterator();

    while (iteratorA.hasNext() && iteratorB.hasNext()) {
      if (!elementEquivalence.equivalent(iteratorA.next(), iteratorB.next())) {
        return false;
      }
    }

    return !iteratorA.hasNext() && !iteratorB.hasNext();
  }

举个例子

看起来是传入一种相等策略,判断两个集合中的元素是否完全相等,default修饰,暂时没看懂怎么使用

二、Supplier

惰性求值。我们可以把耗资源运算放到get方法里,在程序里,我们传递的是Supplier对象,直到调用get方法时,运算才会执行。

全路径:

com.google.common.base

定义

public interface Supplier<T> {
  @CanIgnoreReturnValue
  T get();
}

举个例子

 Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 2;
            }
        };
  int result=supplier.get();

 Suppliers

工具类,提供一些静态方法,生成一些特殊的Supplier

Supplier<T> memoize(Supplier<T> delegate) 返回一个只计算一次的supplier

 Supplier supplier1= Suppliers.memoize(new Supplier<Object>() {
            @Override
            public Object get() {
                return null;
            }
        });

 Supplier<T> memoizeWithExpiration(Supplier<T> delegate, long duration, TimeUnit unit) 返回一个超时的supplier,超时后会重新计算

 Supplier supplier1= Suppliers.memoizeWithExpiration((new Supplier<Object>() {
            @Override
            public Object get() {
                return null;
            }
        }),2,TimeUnit.HOURS);

 Supplier<T> ofInstance(@Nullable T instance) 常量

Supplier supplier= Suppliers.ofInstance(2);

 Supplier<T> compose(Function<? super F, T> function, Supplier<F> supplier) 先计算supplier,再计算funciton

Supplier supplier= Suppliers.compose(new Function<Object, Object>() {
           @Override
           public Object apply(Object input) {
               System.out.println("aaaaaa");
               return null;
           }
       }, new Supplier<Object>() {
           @Override
           public Object get() {
               System.out.println("bbbbbbb");
               return null;
           }
       });

 Supplier<T> synchronizedSupplier(Supplier<T> delegate) 线程安全

 Supplier supplier= Suppliers.synchronizedSupplier(new Supplier() {
           @Override
           public Object get() {
               return null;
           }
       });

 

转载于:https://www.cnblogs.com/amei0/p/9960550.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值