*/
  int size();

  /**
   * Returns {@code true} if this multimap contains no key-value pairs. Equivalent to {@code size()
   * == 0}, but can in some cases be more efficient.
   */
  boolean isEmpty();

  /**
   * Returns {@code true} if this multimap contains at least one key-value pair with the key {@code
   * key}.
   */

 * the return type. For this case, we provide a more expensive workaround in {@code
 * JdkFutureAdapters}. However, when possible, it is more efficient and reliable to create a {@code
 * ListenableFuture} directly.
 *
 * @author Sven Mawson
 * @author Nishant Thakkar
 * @since 1.0
 */
/*

 * the return type. For this case, we provide a more expensive workaround in {@code
 * JdkFutureAdapters}. However, when possible, it is more efficient and reliable to create a {@code
 * ListenableFuture} directly.
 *
 * @author Sven Mawson
 * @author Nishant Thakkar
 * @since 1.0
 */
/*

            ci += NL_LENGTH;
        } while (si < length);

        ps.println(c);
    }

    /**
     * This is an alternative to the <code>java.lang.Integer.toHexString</code>
     * method. It is an efficient relative that also will pad the left side so
     * that the result is <code>size</code> digits.
     *
     * @param val the integer value to convert to hexadecimal

   * approximate size of HTTP/2 headers before they are compressed with HPACK. This value is
   * intended to be used as a metric: smaller headers are more efficient to encode and transmit.
   */
  fun byteCount(): Long {
    // Each header name has 2 bytes of overhead for ': ' and every header value has 2 bytes of
    // overhead for '\r\n'.

   * only the entries for {@code keys} will be returned from {@code getAll}.
   *
   * <p>This method should be overridden when bulk retrieval is significantly more efficient than
   * many individual lookups. Note that {@link LoadingCache#getAll} will defer to individual calls
   * to {@link LoadingCache#get} if this method is not overridden.
   *

        assertFalse(emptyIterator.hasNext(), "Final hasNext check");
        assertNull(emptyIterator.next(), "Final next call");
    }

    @Test
    @DisplayName("EmptyIterator should be lightweight and efficient")
    void testPerformanceCharacteristics() {
        // When - create many instances quickly
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

   * InputStream#skip(long) skip}, if possible) to the end of the stream and return the total number
   * of bytes that were read.
   *
   * <p>Note that for some sources that implement {@link #sizeIfKnown} to provide a more efficient
   * implementation, it is <i>possible</i> that this method will return a different number of bytes
   * than would be returned by reading all of the bytes (for example, some special files may return

    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Chars.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(char[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }

  /**

    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Floats.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(float[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }

  /**