// TODO(kevinb): precompute random #s?
      queue.add(queue.poll() ^ random.nextInt());
    }
  }

  @Benchmark
  void populate(int reps) {
    for (int i = 0; i < reps; i++) {
      queue.clear();
      for (int j = 0; j < size; j++) {
        // TODO(kevinb): precompute random #s?
        queue.add(random.nextInt());
      }
    }
  }

  /**

        last = null;
      }
    };
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override
  public void clear() {
    countMap.clear();
  }

  @WeakOuter
  private final class EntrySet extends AbstractMultiset<E>.EntrySet {
    @Override
    ConcurrentHashMultiset<E> multiset() {
      return ConcurrentHashMultiset.this;

    assertFalse(elementSet.remove(e3()));
    expectUnchanged();
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testElementSetClear() {
    getMultiset().elementSet().clear();
    assertEmpty(getMultiset());
  }

  /**
   * Returns {@link Method} instances for the read tests that assume multisets support duplicates so
   * that the test of {@code Multisets.forSet()} can suppress them.

/// info | Informação

Para usar formulários, primeiro instale <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.

Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalá-lo, por exemplo:

```console
$ pip install python-multipart
```

///

## Importe `Form` { #import-form }

Neste caso, o **FastAPI** nunca tocará ou se importará com o `__init__`, nós vamos utilizar diretamente em nosso código.

## Crie uma instância { #create-an-instance }

Nós poderíamos criar uma instância desta classe com:

{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[18] *}

   *
   * <p>This method is not atomic: the map may not be empty after returning if there were concurrent
   * writes.
   */
  public void clear() {
    map.clear();
  }

  @Override
  public String toString() {
    return map.toString();
  }

  /**
   * If {@code key} is not already associated with a value or if {@code key} is associated with

        out.println("<a class=\"sort\" href=\"?fmt=detail&sort=type\">Type</a>");
        out.println("<a class=\"sort\" style=\"width: 180\" href=\"?fmt=detail&sort=date\">Modified</a><br clear='all'><p>");

        path = dir.getLocator().getCanonicalURL();

        if (path.length() < 7) {
            out.println("<b><big>smb://</big></b><br>");
            path = ".";
        } else {

                    this.witnessClient = null;
                    this.witnessEnabled = false;
                }

                // Clear trees collection atomically
                if (this.trees != null) {
                    this.trees.clear();
                }
            }
        } else if (usage < 0) {
            throw new RuntimeCIFSException("Usage count dropped below zero");
        }

			if err != nil {
				err = msgp.WrapError(err, "ErrCounts")
				return
			}
			if z.ErrCounts == nil {
				z.ErrCounts = make(map[string]int, zb0003)
			} else if len(z.ErrCounts) > 0 {
				clear(z.ErrCounts)
			}
			for zb0003 > 0 {
				zb0003--
				var za0001 string
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "ErrCounts")
					return
				}

    @Override
    public boolean addAll(final int index, final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(index, c);
    }

    @Override
    public void clear() {
        parent.clear();
    }

    @Override
    public boolean contains(final Object o) {
        return parent.contains(o);
    }

    @Override
    public boolean containsAll(final Collection<?> c) {