}

  /**
   * Creates an empty multiset containing the given initial elements, sorted according to the
   * elements' natural order.
   *
   * <p>This implementation is highly efficient when {@code elements} is itself a {@link Multiset}.
   *
   * <p>The type specification is {@code <E extends Comparable>}, instead of the more specific

    assertEquals("", is('a').retainFrom(""));
  }

  public void testPrecomputedOptimizations() {
    // These are testing behavior that's never promised by the API.
    // Some matchers are so efficient that it is a waste of effort to
    // build a precomputed version.
    CharMatcher m1 = is('x');
    assertSame(m1, m1.precomputed());
    assertEquals(m1.toString(), m1.precomputed().toString());

   * is as close as possible to the center of the range [{@code from}, {@code to}]. Choosing the
   * value closest to the center of the range first is the most efficient strategy because it
   * minimizes the size of the subranges from which the remaining selections must be done.
   */
  private static int chooseNextSelection(

  /** The concurrency level. */
  final int concurrencyLevel;

  /** Strategy for comparing keys. */
  final Equivalence<Object> keyEquivalence;

  /** Strategy for handling entries and segments in a type-safe and efficient manner. */
  final transient InternalEntryHelper<K, V, E, S> entryHelper;

  /**
   * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
   */

### Synchronous Get ([.kt][SynchronousGetKotlin], [.java][SynchronousGetJava])

Download a file, print its headers, and print its response body as a string.

The `string()` method on response body is convenient and efficient for small documents. But if the response body is large (greater than 1 MiB), avoid `string()` because it will load the entire document into memory. In that case, prefer to process the body as a stream.

                        // This avoids unnecessary queryPath calls
                        log.trace("Share root existence verified through tree connection");
                    } else {
                        // Use more efficient query for file existence
                        // Prefer SMB2 CreateRequest with minimal access rights over query path
                        if (th.isSMB2()) {
                            try {

   * method is resilient to overflow.
   *
   * @since 14.0
   */
  public static long mean(long x, long y) {
    // Efficient method for computing the arithmetic mean.
    // The alternative (x + y) / 2 fails for large values.
    // The alternative (x + y) >>> 1 fails for negative values.
    return (x & y) + ((x ^ y) >> 1);
  }

  /*

    }

    /**
     * List the contents of this SMB resource as an array of
     * <code>SmbFile</code> objects. This method is much more efficient than
     * the regular <code>list</code> method when querying attributes of each
     * file in the result set.
     * <p>
     * The list of <code>SmbFile</code>s returned by this method will be;
     *

     * {@code Builder} object, even though only one of them will be used in the built map. If there
     * can be many repeated keys, it may be more space-efficient to use a {@link
     * java.util.LinkedHashMap LinkedHashMap} and {@link ImmutableMap#copyOf(Map)} rather than
     * {@code ImmutableMap.Builder}.
     *
     * @since 31.1
     */

                if (attempt % 10 == 0 || attempt < 5) {
                    log.debug("Server not ready yet (attempt {}): {}", attempt + 1, e.getMessage());
                }
                // Use exponential backoff for more efficient waiting
                if (attempt < 10) {
                    Thread.sleep(500); // First 10 attempts: 0.5 second intervals
                } else if (attempt < 30) {