guava(二) Equivalence & Supplier

1、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修飾，暫時沒看懂怎麼使用

2、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;
           }
       });