String str;
        if (obj != null && obj.getClass().isArray()) {
            int n = Array.getLength(obj);
            StringBuilder buf = new StringBuilder(256);
            buf.append('[');
            for (int i = 0; i < n; i++) {
                if (i > 0) {
                    buf.append(", ");
                }
                buf.append(String.valueOf(Array.get(obj, i)));
            }
            buf.append(']');

   * to dump the queue into a newly allocated array of {@code String}:
   *
   * <pre>
   *     String[] y = x.toArray(new String[0]);</pre>
   *
   * <p>Note that {@code toArray(new Object[0])} is identical in function to {@code toArray()}.
   *
   * @param a the array into which the elements of the queue are to be stored, if it is big enough;
   *     otherwise, a new array of the same runtime type is allocated for this purpose

              return false;
            }
          }

          @Override
          @SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
          public <T extends @Nullable Object> T[] toArray(T[] array) {
            T[] result = super.toArray(array);
            if (size() < result.length) {
              // It works around a GWT bug where elements after last is not
              // properly null'ed.

        Object o6 = list.get(5);
        Object[] rest = list.subList(6, list.size()).toArray();
        return ImmutableSet.of(o1, o2, o3, o4, o5, o6, rest);
      }
    },
    COPY_OF_ARRAY {
      @Override
      public ImmutableSet<Object> create(List<?> list) {
        return ImmutableSet.copyOf(list.toArray());
      }
    },
    COPY_OF_LIST {
      @Override

  private final int end; // exclusive

  private ImmutableIntArray(int[] array) {
    this(array, 0, array.length);
  }

  private ImmutableIntArray(int[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
  }

  /** Returns the number of values in this array. */
  public int length() {
    return end - start;
  }

   * i, i + target.length)} contains exactly the same elements as {@code target}.
   *
   * @param array the array to search for the sequence {@code target}
   * @param target the array to search for as a sub-sequence of {@code array}
   */
  public static int indexOf(byte[] array, byte[] target) {
    checkNotNull(array, "array");
    checkNotNull(target, "target");

    E[] array = (E[]) Iterables.toArray(elements);
    checkElementsNotNull(array);
    Arrays.sort(array, comparator);
    return asImmutableList(array);
  }

  private static <E> List<E> nullCheckedList(Object... array) {
    for (int i = 0, len = array.length; i < len; i++) {
      if (array[i] == null) {
        throw new NullPointerException("at index " + i);

  private final int end; // exclusive

  private ImmutableLongArray(long[] array) {
    this(array, 0, array.length);
  }

  private ImmutableLongArray(long[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
  }

  /** Returns the number of values in this array. */
  public int length() {
    return end - start;
  }

          array[i] = counter.getAndIncrement();
        }
        builder.addAll(ImmutableIntArray.copyOf(array));
      }
    },
    ADD_LARGER_ARRAY {
      @Override
      void doIt(ImmutableIntArray.Builder builder, AtomicInteger counter) {
        int[] array = new int[RANDOM.nextInt(200) + 200];
        for (int i = 0; i < array.length; i++) {
          array[i] = counter.getAndIncrement();
        }

    }

    /*
     * Note: the superclass toArray() methods assume that size() gives a correct
     * answer, which ours does not.
     */

    @Override
    public Object[] toArray() {
      return snapshot().toArray();
    }

    @Override
    public <T> T[] toArray(T[] array) {
      return snapshot().toArray(array);
    }

    /*