Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          @Override
          public Integer computeNext() {
            endOfData();
            throw new SomeUncheckedException();
          }
        };
    assertThrows(SomeUncheckedException.class, iter::hasNext);
  }

  public void testCantRemove() {
    Iterator<Integer> iter =

        assertThat(lru.get("aaa"), is("111"));
        Iterator<String> i = lru.keySet().iterator();
        assertThat(i.next(), is("bbb"));
        assertThat(i.next(), is("ccc"));
        assertThat(i.next(), is("aaa"));
        lru.put("ddd", "444");
        assertThat(lru.size(), is(3));
        assertThat(lru.get("bbb"), is(nullValue()));
        i = lru.keySet().iterator();
        assertThat(i.next(), is("ccc"));

   * @return an iterator over the elements in this queue in proper sequence
   */
  @CanIgnoreReturnValue
  @Override
  public Iterator<E> iterator() {
    final Monitor monitor = this.monitor;
    monitor.enter();
    try {
      return new Itr();
    } finally {
      monitor.leave();
    }
  }

  /** Iterator for MonitorBasedArrayBlockingQueue */
  private class Itr implements Iterator<E> {

  @CollectionSize.Require(SEVERAL)
  public void testClearConcurrentWithIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          collection.clear();
          iterator.next();
        });
  }

            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) {

          @Override
          public Iterator<Entry<Range<K>, V>> iterator() {
            return entryIterator();
          }

          @Override
          public boolean retainAll(Collection<?> c) {
            return removeEntryIf(not(in(c)));
          }

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

          @Override

     *            初期容量
     */
    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 {