Base包equivalent

Guava 18.0到22.0 Equivalence发生了较大的变化，这里我们先不可考虑Equivalence 新实现的那个接口，首先看一个测试demo:

import java.util.ArrayList;
import java.util.List;

public class WapperTest {
    public static void main(String[] args) {
        Equivalence<Object> equivalence=Equivalence.equals();
        System.out.println("equals仅仅是做了一个代理");
        System.out.println(equivalence.equivalent("aaa","bbb"));
        System.out.println(equivalence.equivalent("aaa","aaa"));
        Equivalence<String> stringEquivalence=new Equivalence<String>() {
            @Override
            protected boolean doEquivalent(String a, String b) {
                return a.length()==b.length();
            }

            @Override
            protected int doHash(String s) {
                return s.hashCode();
            }
        };
        System.out.println("自己编写的Equivalent");
        System.out.println(stringEquivalence.equivalent("qaa1","ssa1"));
        System.out.println(stringEquivalence.equivalent("oooo","ss"));
        Equivalence.Wrapper<String> stringWrapper1=stringEquivalence.wrap("aaa");
        System.out.println("Wapper错误使用");
        System.out.println(stringWrapper1.equals("saa"));
        Equivalence.Wrapper<String> stringWrapper2=stringEquivalence.wrap("saa");
        System.out.println("Wapper正确使用");   //注意Wapper只有用在和另一个Wapper比较时才有意义，目前还不知道它的使用场景。
        System.out.println(stringWrapper1.equals(stringWrapper2));
        System.out.println("匹配两个可迭代对象");
        List<String> iteratorA=new ArrayList<>();
        iteratorA.add("aaa");
        iteratorA.add("aaa");
        List<String> iteratorB=new ArrayList<>();
        iteratorB.add("bbb");
        iteratorB.add("aaa");
        Equivalence<Iterable<String>> iterableEquivalence=stringEquivalence.pairwise();
        System.out.println(iterableEquivalence.equivalent(iteratorA,iteratorB));
        //System.out.println(stringEquivalence.equivalent(null,null));

    }
}

输出结果：

equals仅仅是做了一个代理
false
true
自己编写的Equivalent
true
false
Wapper错误使用
false
Wapper正确使用
true
匹配两个可迭代对象
true

　Equivalence是用来判断两个对象是否相等，在其中我们可以定制自己的判断逻辑，看一下源码，部分代码略去，本人水平很烂

public abstract class Equivalence<T>  一个抽象类，用于判断两个对象是否相等。equivalent相等的

protected Equivalence() {}   构造函数类型为protected,这是Guava里模板方法的模版类的常见写法（模版方法是常见的设计模式）

public final boolean equivalent(@Nullable T a, @Nullable T b) {   如果两个对象相等，返回true，否则返回false; 核心函数。如果a==null&&b==null,返回true；同一在模板方法中处理空值等特殊情况，简化子类逻辑编写，这是我们写工具类时一个很好的参考。
  if (a == b) {
    return true;
  }
  if (a == null || b == null) {
    return false;
  }
  return doEquivalent(a, b);  否则就调用我们自己定制的判断方法
}

protected abstract boolean doEquivalent(T a, T b);   将判断的控制权交给具体的实现子类。很灵活。

public final int hash(@Nullable T t) {         返回一个对象的hashCode，如果为空，返回0；不为空的话，我们也可以定制自己的hash值。核心函数
  if (t == null) {
    return 0;
  }
  return doHash(t);
}

protected abstract int doHash(T t);                    同样将具体实现交给实现类去做，和上个方法一样，在模版方法做了判空等操作，简化了子类代码的编写复杂度。
public static Equivalence<Object> equals() {  这个函数以及下个函数很简单，这个是调用a.equals(b)判断两个元素是否相等，用类的hashCode()返回对象的hash值

  return Equals.INSTANCE;}

public static Equivalence<Object> identity() {   只有a==b是两个元素才是相等的。hash调用的是System.identityHashCode(o)，不知道什么鬼

 return Identity.INSTANCE; }

public final <S extends T> Wrapper<S> wrap(@Nullable S reference)   创造一个Wapper，详情请看另一篇博客，只不过没啥意义，很简单

public final <S extends T> Equivalence<Iterable<S>> pairwise()  返回一个Equivalence<Iterable<s>>,用于匹配两个可迭代对象是否相等，对于可迭代对象推荐
                                                                用这种方法。

public final <F> Equivalence<F> onResultOf(Function<F, ? extends T> function) 不知道怎么解释。把核心代码贴出来，很简单

@Override
protected boolean doEquivalent(F a, F b) {        我想他的应用场景应该是和pairwise,结合使用，在处理前对数据进行一定的处理。
  return resultEquivalence.equivalent(function.apply(a), function.apply(b));
}

@Override
protected int doHash(F a) {
  return resultEquivalence.hash(function.apply(a));
}