How to use

com.google.common.collect.Maps$SortedMapDifferenceImpl

constructor

/**
 * Computes the difference between two sorted maps, using the comparator of the left map, or
 * {@code Ordering.natural()} if the left map uses the natural ordering of its elements. This
 * difference is an immutable snapshot of the state of the maps at the time this method is called.
 * It will never change, even if the maps change at a later time.
 *
 * <p>Since this method uses {@code TreeMap} instances internally, the keys of the right map must
 * all compare as distinct according to the comparator of the left map.
 *
 * <p><b>Note:</b>If you only need to know whether two sorted maps have the same mappings, call
 * {@code left.equals(right)} instead of this method.
 *
 * @param left the map to treat as the "left" map for purposes of comparison
 * @param right the map to treat as the "right" map for purposes of comparison
 * @return the difference between the two maps
 * @since 11.0
 */
public static <K, V> SortedMapDifference<K, V> difference(
  SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right) {
 checkNotNull(left);
 checkNotNull(right);
 Comparator<? super K> comparator = orNaturalOrder(left.comparator());
 SortedMap<K, V> onlyOnLeft = Maps.newTreeMap(comparator);
 SortedMap<K, V> onlyOnRight = Maps.newTreeMap(comparator);
 onlyOnRight.putAll(right); // will whittle it down
 SortedMap<K, V> onBoth = Maps.newTreeMap(comparator);
 SortedMap<K, MapDifference.ValueDifference<V>> differences = Maps.newTreeMap(comparator);
 doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
 return new SortedMapDifferenceImpl<>(onlyOnLeft, onlyOnRight, onBoth, differences);
}

/**
 * Computes the difference between two sorted maps, using the comparator of the left map, or
 * {@code Ordering.natural()} if the left map uses the natural ordering of its elements. This
 * difference is an immutable snapshot of the state of the maps at the time this method is called.
 * It will never change, even if the maps change at a later time.
 *
 * <p>Since this method uses {@code TreeMap} instances internally, the keys of the right map must
 * all compare as distinct according to the comparator of the left map.
 *
 * <p><b>Note:</b>If you only need to know whether two sorted maps have the same mappings, call
 * {@code left.equals(right)} instead of this method.
 *
 * @param left the map to treat as the "left" map for purposes of comparison
 * @param right the map to treat as the "right" map for purposes of comparison
 * @return the difference between the two maps
 * @since 11.0
 */
public static <K, V> SortedMapDifference<K, V> difference(
  SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right) {
 checkNotNull(left);
 checkNotNull(right);
 Comparator<? super K> comparator = orNaturalOrder(left.comparator());
 SortedMap<K, V> onlyOnLeft = Maps.newTreeMap(comparator);
 SortedMap<K, V> onlyOnRight = Maps.newTreeMap(comparator);
 onlyOnRight.putAll(right); // will whittle it down
 SortedMap<K, V> onBoth = Maps.newTreeMap(comparator);
 SortedMap<K, MapDifference.ValueDifference<V>> differences = Maps.newTreeMap(comparator);
 doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
 return new SortedMapDifferenceImpl<>(onlyOnLeft, onlyOnRight, onBoth, differences);
}

private enum EntryFunction implements Function<Entry<?, ?>, Object> {
 KEY {
  @Override
  @NullableDecl
  public Object apply(Entry<?, ?> entry) {
   return entry.getKey();
  }
 },
 VALUE {
  @Override
  @NullableDecl
  public Object apply(Entry<?, ?> entry) {
   return entry.getValue();
  }
 };
}

  Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

  Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

SortedMap<K, MapDifference.ValueDifference<V>> differences = Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

  Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

  Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

  Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

/**
 * Computes the difference between two sorted maps, using the comparator of the left map, or
 * {@code Ordering.natural()} if the left map uses the natural ordering of its elements. This
 * difference is an immutable snapshot of the state of the maps at the time this method is called.
 * It will never change, even if the maps change at a later time.
 *
 * <p>Since this method uses {@code TreeMap} instances internally, the keys of the right map must
 * all compare as distinct according to the comparator of the left map.
 *
 * <p><b>Note:</b>If you only need to know whether two sorted maps have the same mappings, call
 * {@code left.equals(right)} instead of this method.
 *
 * @param left the map to treat as the "left" map for purposes of comparison
 * @param right the map to treat as the "right" map for purposes of comparison
 * @return the difference between the two maps
 * @since 11.0
 */
public static <K, V> SortedMapDifference<K, V> difference(
  SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right) {
 checkNotNull(left);
 checkNotNull(right);
 Comparator<? super K> comparator = orNaturalOrder(left.comparator());
 SortedMap<K, V> onlyOnLeft = Maps.newTreeMap(comparator);
 SortedMap<K, V> onlyOnRight = Maps.newTreeMap(comparator);
 onlyOnRight.putAll(right); // will whittle it down
 SortedMap<K, V> onBoth = Maps.newTreeMap(comparator);
 SortedMap<K, MapDifference.ValueDifference<V>> differences = Maps.newTreeMap(comparator);
 doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
 return new SortedMapDifferenceImpl<>(onlyOnLeft, onlyOnRight, onBoth, differences);
}

/**
 * Computes the difference between two sorted maps, using the comparator of the left map, or
 * {@code Ordering.natural()} if the left map uses the natural ordering of its elements. This
 * difference is an immutable snapshot of the state of the maps at the time this method is called.
 * It will never change, even if the maps change at a later time.
 *
 * <p>Since this method uses {@code TreeMap} instances internally, the keys of the right map must
 * all compare as distinct according to the comparator of the left map.
 *
 * <p><b>Note:</b>If you only need to know whether two sorted maps have the same mappings, call
 * {@code left.equals(right)} instead of this method.
 *
 * @param left the map to treat as the "left" map for purposes of comparison
 * @param right the map to treat as the "right" map for purposes of comparison
 * @return the difference between the two maps
 * @since 11.0
 */
public static <K, V> SortedMapDifference<K, V> difference(
  SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right) {
 checkNotNull(left);
 checkNotNull(right);
 Comparator<? super K> comparator = orNaturalOrder(left.comparator());
 SortedMap<K, V> onlyOnLeft = Maps.newTreeMap(comparator);
 SortedMap<K, V> onlyOnRight = Maps.newTreeMap(comparator);
 onlyOnRight.putAll(right); // will whittle it down
 SortedMap<K, V> onBoth = Maps.newTreeMap(comparator);
 SortedMap<K, MapDifference.ValueDifference<V>> differences = Maps.newTreeMap(comparator);
 doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
 return new SortedMapDifferenceImpl<>(onlyOnLeft, onlyOnRight, onBoth, differences);
}

  Maps.newTreeMap(comparator);
doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
return new SortedMapDifferenceImpl<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);

private static <K, V> SortedMapDifference<K, V> sortedMapDifference(
  boolean areEqual, SortedMap<K, V> onlyOnLeft, SortedMap<K, V> onlyOnRight,
  SortedMap<K, V> onBoth, SortedMap<K, ValueDifference<V>> differences) {
 return new SortedMapDifferenceImpl<K, V>(areEqual,
   Collections.unmodifiableSortedMap(onlyOnLeft),
   Collections.unmodifiableSortedMap(onlyOnRight),
   Collections.unmodifiableSortedMap(onBoth),
   Collections.unmodifiableSortedMap(differences));
}

private static <K, V> SortedMapDifference<K, V> sortedMapDifference(
  boolean areEqual, SortedMap<K, V> onlyOnLeft, SortedMap<K, V> onlyOnRight,
  SortedMap<K, V> onBoth, SortedMap<K, ValueDifference<V>> differences) {
 return new SortedMapDifferenceImpl<K, V>(areEqual,
   Collections.unmodifiableSortedMap(onlyOnLeft),
   Collections.unmodifiableSortedMap(onlyOnRight),
   Collections.unmodifiableSortedMap(onBoth),
   Collections.unmodifiableSortedMap(differences));
}