code: 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<K, V>(onlyOnLeft, onlyOnRight, onBoth, differences);
    }
docs: 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