* class to begin with but rather something returned from a static factory method whose declared
   * return type is plain FilenameFilter. If we made such a change, then the annotation we choose
   * here would have no significance to end users, who would be forced to conform to the signature
   * used in FilenameFilter.)
   */
  @Override

into the air off all its feet at once, with a yelp of delight,
and rushed at the stick, and made believe to worry it; then Alice
dodged behind a great thistle, to keep herself from being run
over; and the moment she appeared on the other side, the puppy
made another rush at the stick, and tumbled head over heels in
its hurry to get hold of it; then Alice, thinking it was very

 * #iterator()} method after the first, and whose iterator is always unmodifiable.
 *
 * <p>The {@code Iterable} specification does not make it absolutely clear what should happen on a
 * second invocation, so implementors have made various choices, including:
 *
 * <ul>
 *   <li>returning the same iterator again
 *   <li>throwing an exception of some kind
 *   <li>or the usual, <i>robust</i> behavior, which all known {@link Collection} implementations

   * the {@code shutdownNow} method. First, "best-effort" with regards to canceling running tasks is
   * implemented as "no-effort". No interrupts or other attempts are made to stop threads executing
   * tasks. Second, the returned list will always be empty, as any submitted task is considered to
   * have started execution. This applies also to tasks given to {@code invokeAll} or {@code

   * comparator.
   */
  @Override
  Iterator<E> iterator();

  /**
   * Returns a descending view of this multiset. Modifications made to either map will be reflected
   * in the other.
   */
  SortedMultiset<E> descendingMultiset();

  /**
   * Returns a view of this multiset restricted to the elements less than {@code upperBound},

   * the caller when the timeout elapses; aborting the target method call is of secondary concern.
   * The particular nature and strength of the guarantees made by the proxy is
   * implementation-dependent. However, it is important that each of the methods on the target
   * object behaves appropriately when its thread is interrupted.
   *

   * all values is returned.
   *
   */
  CacheStats stats();

  /**
   * Returns a view of the entries stored in this cache as a thread-safe map. Modifications made to
   * the map directly affect the cache.
   *
   * <p>Iterators from the returned map are at least <i>weakly consistent</i>: they are safe for

   *
   * <p>If this method throws, e.g. a {@code RejectedExecutionException} from the delegate executor,
   * execution of tasks will stop until a call to this method is made.
   */
  @Override
  public void execute(Runnable task) {
    checkNotNull(task);
    Runnable submittedTask;
    long oldRunCount;
    synchronized (queue) {

   * used for another unchecked exception, an exception during string formatting would serve little
   * purpose except to supplant the real information you were trying to provide. These are the cases
   * this method is made for; it instead generates a best-effort string with all supplied argument
   * values present. This method is also useful in environments such as GWT where {@code

     *
     * @param element the element to add
     * @param occurrences the number of occurrences of the element to add. May be zero, in which
     *     case no change will be made.
     * @return this {@code Builder} object
     * @throws NullPointerException if {@code element} is null
     * @throws IllegalArgumentException if {@code occurrences} is negative, or if this operation