How to use

addAll

method

in

java.util.Collections

private void addOtherElementToBeReturned(List<Object> elements, Object[] toBeReturnedOthers) {
  if (toBeReturnedOthers == null) {
    elements.add(toBeReturnedOthers);
    return;
  }
  Collections.addAll(elements, toBeReturnedOthers);
}

@Override
public void addHeader(Header header) {
 List<Header> temp = new ArrayList<>();
 Collections.addAll(temp, headers);
 temp.add(header);
 headers = temp.toArray(new Header[temp.size()]);
}

 String[] f(String[] first, String[] second) {
  List<String> both = new ArrayList<String>(first.length + second.length);
  Collections.addAll(both, first);
  Collections.addAll(both, second);
  return both.toArray(new String[both.size()]);
}

private List<List<Double>> convertToListOfLists(final List<Double[]> points) {
  List<List<Double>> listOfLists = new ArrayList<List<Double>>(points.size());
  for (Double[] cur : points) {
    List<Double> list = new ArrayList<Double>(cur.length);
    Collections.addAll(list, cur);
    listOfLists.add(list);
  }
  return listOfLists;
}

public Java8() {
  super();
  List<Class<?>> dgmClasses = new ArrayList<>();
  Collections.addAll(dgmClasses, (Class<?>[]) super.getPluginDefaultGroovyMethods());
  dgmClasses.add(PluginDefaultGroovyMethods.class);
  PLUGIN_DGM = dgmClasses.toArray(new Class<?>[0]);
}

private static Address[] addressFromStringArray(List<String> addresses) {
  ArrayList<Address> result = new ArrayList<>(addresses.size());
  for (String addressStr : addresses) {
    Collections.addAll(result, Address.parseUnencoded(addressStr));
  }
  return result.toArray(new Address[result.size()]);
}

public Ansi and(Ansi other) {
  List<String> both = new ArrayList<String>();
  Collections.addAll(both, codes);
  Collections.addAll(both, other.codes);
  return new Ansi(both.toArray(new String[]{}));
}

/**
 * Gets the current settings of KDtree.
 * 
 * @return an array of strings suitable for passing to setOptions
 */
@Override
public String[] getOptions() {
 Vector<String> result = new Vector<String>();
 result.add("-S");
 result.add(m_Splitter.getClass().getName());
 Collections.addAll(result, super.getOptions());
 return result.toArray(new String[result.size()]);
}

protected Object[] expandStringArgs(Object... args) {
  List<Object> argList = new ArrayList<>();
  for (Object arg : args) {
    if (arg instanceof Object[]) {
      Collections.addAll(argList, (Object[])arg);
    } else {
      argList.add(arg);
    }
  }
  return argList.toArray(new Object[argList.size()]);
}

      newSequence.add(subInvokable);
    newSequence.add(invokable);
    Collections.addAll(newSequence, ((Sequence) invokable).sequence);
  } else {
    newSequence.add(invokable);
  newValueMap.put(caseValue, newSequence.size());
  Collections.addAll(newSequence, ((Sequence) invokable).sequence);
} else {
  newSequence.add(invokable);

/**
 * Returns all methods. Cached. Lazy.
 */
public MethodDescriptor[] getAllMethodDescriptors() {
  if (allMethods == null) {
    List<MethodDescriptor> allMethodsList = new ArrayList<>();
    for (MethodDescriptor[] methodDescriptors : methodsMap.values()) {
      Collections.addAll(allMethodsList, methodDescriptors);
    }
    MethodDescriptor[] allMethods = allMethodsList.toArray(new MethodDescriptor[allMethodsList.size()]);
    Arrays.sort(allMethods, new Comparator<MethodDescriptor>() {
      public int compare(MethodDescriptor md1, MethodDescriptor md2) {
        return md1.getMethod().getName().compareTo(md2.getMethod().getName());
      }
    });
    this.allMethods = allMethods;
  }
  return allMethods;
}

/**
 * Add default filters to apply to each request.
 *
 * @param filter            The filter to add
 * @param additionalFilters An optional array of additional filters to add
 */
public static void filters(Filter filter, Filter... additionalFilters) {
  Validate.notNull(filter, "Filter cannot be null");
  RestAssured.filters.add(filter);
  if (additionalFilters != null) {
    Collections.addAll(RestAssured.filters, additionalFilters);
  }
}

static Rescorer of(List<Rescorer> rescorers) {
 List<Rescorer> expandedRescorers = new ArrayList<>();
 for (Rescorer rescorer : rescorers) {
  // Assuming at most one level of nesting here
  if (rescorer instanceof MultiRescorer) {
   Collections.addAll(expandedRescorers, ((MultiRescorer) rescorer).getRescorers());
  } else {
   expandedRescorers.add(rescorer);
  }
 }
 return new MultiRescorer(expandedRescorers.toArray(EMPTY_RESCORER_ARRAY));
}

public ChainWALEntryFilter(List<WALEntryFilter> filters) {
 ArrayList<WALEntryFilter> rawFilters = new ArrayList<>(filters.size());
 // flatten the chains
 for (WALEntryFilter filter : filters) {
  if (filter instanceof ChainWALEntryFilter) {
   Collections.addAll(rawFilters, ((ChainWALEntryFilter) filter).filters);
  } else {
   rawFilters.add(filter);
  }
 }
 this.filters = rawFilters.toArray(new WALEntryFilter[rawFilters.size()]);
 initCellFilters();
}

public Ansi and(Ansi other) {
  List<String> both = new ArrayList<String>();
  Collections.addAll(both, codes);
  Collections.addAll(both, other.codes);
  return new Ansi(both.toArray(new String[]{}));
}

/**
 * Gets the current settings of the classifier.
 * 
 * @return an array of strings suitable for passing to setOptions
 */
@Override
public String[] getOptions() {
 Vector<String> result = new Vector<String>();
 result.add("-N");
 result.add("" + m_filterType);
 Collections.addAll(result, super.getOptions());
 return result.toArray(new String[result.size()]);
}

private void setServicePackagePrefixes( String packages ) {
  List<String> packagePrefixes = new ArrayList<String>();
  Collections.addAll(packagePrefixes, package_prefixes);
  String[] prefixes = packages.split( ";" );
  for ( String prefix : prefixes ) {
    if ( !packagePrefixes.contains( prefix ) ) {
      packagePrefixes.add( prefix );
    }
  }
  package_prefixes = packagePrefixes.toArray( new String[packagePrefixes.size()] );
}

String name = parser.getName();
if (name.equals("poi_category")) {
  lastCategory = new PoiCategory(this, parser.getAttributeValue("", "name"), categories.size());
  lastCategory.setTopVisible(Boolean.parseBoolean(parser.getAttributeValue("", "top")));
  lastCategory.setNotEditableOsm("true".equals(parser.getAttributeValue("", "no_edit")));
  lastCategory.setDefaultTag(parser.getAttributeValue("", "default_tag"));
  if(!Algorithms.isEmpty(parser.getAttributeValue("", "poi_additional_category"))) {
    Collections.addAll(lastCategoryPoiAdditionalsCategories, parser.getAttributeValue("", "poi_additional_category").split(","));
    lastCategoryPoiAdditionalsCategories.removeAll(lastCategory.getExcludedPoiAdditionalCategories());
  categories.add(lastCategory);
} else if (name.equals("poi_filter")) {
  PoiFilter tp = new PoiFilter(this, lastCategory, parser.getAttributeValue("", "name"));
  lastFilterPoiAdditionalsCategories.addAll(lastCategoryPoiAdditionalsCategories);
  if(!Algorithms.isEmpty(parser.getAttributeValue("", "poi_additional_category"))) {
    Collections.addAll(lastFilterPoiAdditionalsCategories, parser.getAttributeValue("", "poi_additional_category").split(","));
      categoryPoiAdditionalMap.put(lastPoiAdditionalCategory, categoryAdditionals);
    categoryAdditionals.add(baseType);
    lastTypePoiAdditionalsCategories.addAll(lastFilterPoiAdditionalsCategories);
    if(!Algorithms.isEmpty(parser.getAttributeValue("", "poi_additional_category"))) {
      Collections.addAll(lastTypePoiAdditionalsCategories, parser.getAttributeValue("", "poi_additional_category").split(","));

public void setInstallations(MavenInstallation... installations) {
  List<MavenInstallation> tmpList = new ArrayList<Maven.MavenInstallation>();
  // remote empty Maven installation : 
  if(installations != null) {
    Collections.addAll(tmpList, installations);
    for(MavenInstallation installation : installations) {
      if(Util.fixEmptyAndTrim(installation.getName()) == null) {
        tmpList.remove(installation);
      }
    }
  }
  this.installations = tmpList.toArray(new MavenInstallation[tmpList.size()]);
  save();
}

/**
 * Create a composite logger that delegates to a primary or falls back on a
 * secondary logger if logging for the primary logger is not enabled.
 * <p>This may be used for fallback logging from lower level packages that
 * logically should log together with some higher level package but the two
 * don't happen to share a suitable parent package (e.g. logging for the web
 * and lower level http and codec packages). For such cases the primary,
 * class-based logger can be wrapped with a shared fallback logger.
 * @param primaryLogger primary logger to try first
 * @param secondaryLogger secondary logger
 * @param tertiaryLoggers optionally, more fallback loggers
 * @return the resulting logger to use
 */
public static Log getCompositeLog(Log primaryLogger, Log secondaryLogger, Log... tertiaryLoggers) {
  List<Log> loggers = new ArrayList<>(2 + tertiaryLoggers.length);
  loggers.add(primaryLogger);
  loggers.add(secondaryLogger);
  Collections.addAll(loggers, tertiaryLoggers);
  return new CompositeLog(loggers);
}