Java Equivalence类代码示例

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToImmutableSortedMap() {
  Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
      ImmutableSortedMap.toImmutableSortedMap(
          String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>>
      equivalence =
          Equivalence.equals().onResultOf(ImmutableSortedMap<String, Integer>::comparator)
              .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList()))
              .and(Equivalence.equals());
  ImmutableSortedMap<String, Integer> expected =
      ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER)
          .put("one", 1)
          .put("three", 3)
          .put("two", 2)
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToImmutableTable() {
  Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
      ImmutableTable.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue);
  Equivalence<ImmutableTable<String, String, Integer>> equivalence =
      Equivalence.equals()
          .<Cell<String, String, Integer>>pairwise()
          .onResultOf(ImmutableTable::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 2)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
private <T extends PresortedComparable<T>, S extends KeyedDexItem<T>> void addNonShadowed(
    Iterator<S> items,
    HashMap<Wrapper<T>, S> map,
    Equivalence<T> equivalence,
    Set<Wrapper<T>> existing,
    BiFunction<S, S, S> onConflict) {
  while (items.hasNext()) {
    S item = items.next();
    if (item == null) {
      // This item was filtered out by a preprocessing.
      continue;
    }
    Wrapper<T> wrapped = equivalence.wrap(item.getKey());
    if (existing.contains(wrapped)) {
      S resolved = onConflict.apply(map.get(wrapped), item);
      wrapped = equivalence.wrap(resolved.getKey());
      map.put(wrapped, resolved);
    } else {
      map.put(wrapped, item);
    }
  }
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
private void testLogicalKeyEquality(
    MapMakerInternalMap.Strength keyStrength) {

  ConcurrentMap<String, AtomicInteger> map =
      new MapMaker().setKeyStrength(keyStrength).keyEquivalence(Equivalence.equals()).makeMap();

  ConcurrentHashMultiset<String> multiset = ConcurrentHashMultiset.create(map);

  String s1 = new String("a");
  String s2 = new String("a");
  assertEquals(s1, s2); // Stating the obvious.

  multiset.add(s1);
  assertTrue(multiset.contains(s1));
  assertTrue(multiset.contains(s2));
  assertEquals(1, multiset.count(s1));
  assertEquals(1, multiset.count(s2));

  multiset.add(s2, 3);
  assertEquals(4, multiset.count(s1));
  assertEquals(4, multiset.count(s2));

  multiset.remove(s1);
  assertEquals(3, multiset.count(s1));
  assertEquals(3, multiset.count(s2));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToMultimap() {
  Collector<Entry<String, Integer>, ?, TreeMultimap<String, Integer>> collector =
      Multimaps.toMultimap(Entry::getKey, Entry::getValue, TreeMultimap::create);
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  TreeMultimap<String, Integer> empty = TreeMultimap.create();
  TreeMultimap<String, Integer> filled = TreeMultimap.create();
  filled.put("a", 1);
  filled.put("a", 2);
  filled.put("b", 2);
  filled.put("c", 3);
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(
          filled, mapEntry("a", 1), mapEntry("a", 2), mapEntry("b", 2), mapEntry("c", 3));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testFlatteningToMultimap() {
  Collector<String, ?, ListMultimap<Character, Character>> collector =
      Multimaps.flatteningToMultimap(
          str -> str.charAt(0),
          str -> str.substring(1).chars().mapToObj(c -> (char) c),
          MultimapBuilder.linkedHashKeys().arrayListValues()::build);
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ListMultimap<Character, Character> empty =
      MultimapBuilder.linkedHashKeys().arrayListValues().build();
  ListMultimap<Character, Character> filled =
      MultimapBuilder.linkedHashKeys().arrayListValues().build();
  filled.putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'));
  filled.putAll('a', Arrays.asList('p', 'p', 'l', 'e'));
  filled.putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'));
  filled.putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'));
  filled.putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'));
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testSetKeyEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  MapMakerInternalMap<Object, Object, ?, ?> map =
      makeMap(createMapMaker().keyEquivalence(testEquivalence));
  assertSame(testEquivalence, map.keyEquivalence);
  assertSame(map.valueStrength().defaultEquivalence(), map.valueEquivalence());
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToImmutableListMultimap() {
  Collector<Entry<String, Integer>, ?, ImmutableListMultimap<String, Integer>> collector =
      ImmutableListMultimap.toImmutableListMultimap(Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableListMultimap<?, ?>, ImmutableListMultimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((ImmutableListMultimap<?, ?> mm) -> mm.asMap().entrySet().asList())
          .and(Equivalence.equals());
  CollectorTester.of(collector, equivalence)
      .expectCollects(ImmutableListMultimap.of())
      .expectCollects(
          ImmutableListMultimap.of("a", 1, "b", 2, "a", 3, "c", 4),
          mapEntry("a", 1),
          mapEntry("b", 2),
          mapEntry("a", 3),
          mapEntry("c", 4));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testFlatteningToImmutableListMultimap() {
  Collector<String, ?, ImmutableListMultimap<Character, Character>> collector =
      ImmutableListMultimap.flatteningToImmutableListMultimap(
          str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c));
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ImmutableListMultimap<Character, Character> empty = ImmutableListMultimap.of();
  ImmutableListMultimap<Character, Character> filled =
      ImmutableListMultimap.<Character, Character>builder()
          .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
          .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
          .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
          .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
          .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToImmutableTableMerging() {
  Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
      ImmutableTable.toImmutableTable(
          Cell::getRowKey, Cell::getColumnKey, Cell::getValue, Integer::sum);
  Equivalence<ImmutableTable<String, String, Integer>> equivalence =
      Equivalence.equals()
          .<Cell<String, String, Integer>>pairwise()
          .onResultOf(ImmutableTable::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 6)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3),
          Tables.immutableCell("two", "dos", 4));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToImmutableSetMultimap() {
  Collector<Entry<String, Integer>, ?, ImmutableSetMultimap<String, Integer>> collector =
      ImmutableSetMultimap.toImmutableSetMultimap(Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableSetMultimap<?, ?>, ImmutableSetMultimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf(
              (ImmutableSetMultimap<?, ?> mm)
                  -> ImmutableListMultimap.copyOf(mm).asMap().entrySet().asList())
          .and(Equivalence.equals());
  CollectorTester.of(collector, equivalence)
      .expectCollects(ImmutableSetMultimap.of())
      .expectCollects(
          ImmutableSetMultimap.of("a", 1, "b", 2, "a", 3, "c", 4),
          mapEntry("a", 1),
          mapEntry("b", 2),
          mapEntry("a", 3),
          mapEntry("c", 4));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testToImmutableSortedMapMerging() {
  Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
      ImmutableSortedMap.toImmutableSortedMap(
          Comparator.naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum);
  Equivalence<ImmutableMap<String, Integer>> equivalence =
      Equivalence.equals()
          .<Entry<String, Integer>>pairwise()
          .onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableSortedMap.of("one", 1, "three", 3, "two", 4),
          mapEntry("one", 1),
          mapEntry("two", 2),
          mapEntry("three", 3),
          mapEntry("two", 2));
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testFlatteningToImmutableSetMultimap() {
  Collector<String, ?, ImmutableSetMultimap<Character, Character>> collector =
      ImmutableSetMultimap.flatteningToImmutableSetMultimap(
          str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c));
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ImmutableSetMultimap<Character, Character> empty = ImmutableSetMultimap.of();
  ImmutableSetMultimap<Character, Character> filled =
      ImmutableSetMultimap.<Character, Character>builder()
          .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
          .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
          .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
          .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
          .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testSetKeyEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  LocalCache<Object, Object> map =
      makeLocalCache(createCacheBuilder().keyEquivalence(testEquivalence));
  assertSame(testEquivalence, map.keyEquivalence);
  assertSame(map.valueStrength.defaultEquivalence(), map.valueEquivalence);
}
 

import com.google.common.base.Equivalence; //导入依赖的package包/类
public void testSetValueEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  LocalCache<Object, Object> map =
      makeLocalCache(createCacheBuilder().valueEquivalence(testEquivalence));
  assertSame(testEquivalence, map.valueEquivalence);
  assertSame(map.keyStrength.defaultEquivalence(), map.keyEquivalence);
}