DependencyManagement target,
            DependencyManagement source,
            boolean sourceDominant,
            Map<Object, Object> context) {
        Iterator<Dependency> sourceIterator = source.getDependencies().iterator();
        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))

      SortedSet<@Nullable Object> self = (SortedSet<@Nullable Object>) this;
      Iterator<?> iterator = self.tailSet(object).iterator();
      if (iterator.hasNext()) {
        Object ceiling = iterator.next();
        if (unsafeCompare(comparator(), ceiling, object) == 0) {
          iterator.remove();
          return true;
        }
      }
    } catch (ClassCastException | NullPointerException e) {

     *            初期容量
     */
    public CaseInsensitiveSet(final int initialCapacity) {
        map = new CaseInsensitiveMap<>(initialCapacity);
    }

    @Override
    public Iterator<String> iterator() {
        return map.keySet().iterator();
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

  }

  /**
   * A sensible default implementation of {@link #iterator}, in terms of {@link #listIterator()}. If
   * you override {@link #listIterator()}, you may wish to override {@link #iterator} to forward to
   * this implementation.
   *
   * @since 7.0
   */
  protected Iterator<E> standardIterator() {
    return listIterator();
  }

  /**

    List<Object> list = new ArrayList<>();
    assertEmpty(list);
    assertEmpty(
        new Iterable<Object>() {
          @Override
          public Iterator<Object> iterator() {
            return emptyList().iterator();
          }
        });

    list.add("a");
    try {
      assertEmpty(list);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
    try {

    List<Object> list = new ArrayList<>();
    assertEmpty(list);
    assertEmpty(
        new Iterable<Object>() {
          @Override
          public Iterator<Object> iterator() {
            return emptyList().iterator();
          }
        });

    list.add("a");
    try {
      assertEmpty(list);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
    try {

    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }

    @Override
    public Iterator<E> iterator() {
      return elementIterator();
    }
  }

  abstract Iterator<E> elementIterator();

  @LazyInit @CheckForNull private transient Set<Entry<E>> entrySet;

  @Override
  public Set<Entry<E>> entrySet() {

   */
  Comparator<? super T> comparator();

  /**
   * Returns an iterator over elements of type {@code T}. The elements are returned in nondecreasing
   * order according to the associated {@link #comparator}.
   */
  @Override
  Iterator<T> iterator();

   */
  Comparator<? super T> comparator();

  /**
   * Returns an iterator over elements of type {@code T}. The elements are returned in nondecreasing
   * order according to the associated {@link #comparator}.
   */
  @Override
  Iterator<T> iterator();

    multimap.put("foo", 2);
    multimap.put("bar", 3);
    Collection<Entry<String, Integer>> entries = multimap.entries();
    Iterator<Entry<String, Integer>> iterator = entries.iterator();
    Entry<String, Integer> entrya = iterator.next();
    Entry<String, Integer> entryb = iterator.next();

    assertEquals(2, (int) multimap.get("foo").set(0, 4));
    assertFalse(multimap.containsEntry("foo", 2));