@Override
    public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

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

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

    @Override
    public String toString() {
      return standardToString();
    }
  }

    @Override
    public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

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

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

    @Override
    public String toString() {
      return standardToString();
    }

      }
    }
    return sum;
  }

  @Benchmark
  int arrayListToArrayFor(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Object value : arrayList.toArray()) {
        sum += value.hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int linkedListFor(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {

    map.putInstance(String.class, "test");
    @SuppressWarnings("unchecked") // Should get a CCE later if cast is wrong
    Entry<?, Object> entry = (Entry<?, Object>) map.entrySet().toArray()[0];
    assertEquals(TypeToken.of(String.class), entry.getKey());
    assertEquals("test", entry.getValue());
    assertThrows(UnsupportedOperationException.class, () -> entry.setValue(1));
  }

                            .toArray(n -> new String[n])));
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
            entity.setPermissions(split(form.permissions, "\n").get(stream -> stream.map(s -> permissionHelper.encode(s))
                    .filter(StringUtil::isNotBlank)
                    .distinct()
                    .toArray(n -> new String[n])));

                            .toArray(n -> new String[n])));
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
            entity.setPermissions(split(form.permissions, "\n").get(stream -> stream.map(s -> permissionHelper.encode(s))
                    .filter(StringUtil::isNotBlank)
                    .distinct()
                    .toArray(n -> new String[n])));

         */
        public String[] getAllows() {
            return allowedPaths.toArray(new String[allowedPaths.size()]);
        }

        /**
         * Gets all disallowed paths for this directive.
         * @return an array of disallowed paths
         */
        public String[] getDisallows() {
            return disallowedPaths.toArray(new String[disallowedPaths.size()]);
        }
    }

    /**

        super(indexSettings, name, settings);

        final List<String> wordList = Analysis.parseWordList(environment, settings, "stopwords", s -> s);
        if (wordList != null) {
            stopwords = wordList.toArray(new String[wordList.size()]);
        } else {
            stopwords = new String[0];
        }

        ignoreCase = settings.getAsBoolean("ignore_case", Boolean.FALSE).booleanValue();
        if (ignoreCase) {

  protected E[] createSamplesArray() {
    E[] array = getSubjectGenerator().createArray(getNumElements());
    getSampleElements().toArray(array);
    return array;
  }

  protected E[] createOrderedArray() {
    E[] array = getSubjectGenerator().createArray(getNumElements());
    getOrderedElements().toArray(array);
    return array;
  }

  public static class ArrayWithDuplicate<E extends @Nullable Object> {

                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));
        fileProtocols = split(fessConfig.getCrawlerFileProtocols(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));

        loadProtocols("org.codelibs.fess.net.protocol");

        if (logger.isDebugEnabled()) {