How to use

toArray

method

in

java.util.stream.Stream

private static AggregatorFactory[] convertToCombiningFactories(AggregatorFactory[] metricsSpec)
{
 return Arrays.stream(metricsSpec)
        .map(AggregatorFactory::getCombiningFactory)
        .toArray(AggregatorFactory[]::new);
}

public Factory(List<Supplier<LookupSource>> partitions)
{
  this.lookupSources = partitions.stream()
      .map(Supplier::get)
      .toArray(LookupSource[]::new);
  visitedPositions = Arrays.stream(this.lookupSources)
      .map(LookupSource::getJoinPositionCount)
      .map(Math::toIntExact)
      .map(boolean[]::new)
      .toArray(boolean[][]::new);
}

protected static String[] extractFactoryName(final List<AggregatorFactory> aggregatorFactories)
{
 return aggregatorFactories.stream().map(AggregatorFactory::getName).toArray(String[]::new);
}

private static String[] getJarsFullPaths( String... jars )
{
  return Stream.of( jars )
      .map( LuceneExplicitIndexUpgrader::getJarPath ).toArray( String[]::new );
}

public static ValueType[] typesOfGroup( ValueGroup valueGroup )
{
  return Arrays.stream( ValueType.values() )
      .filter( t -> t.valueGroup == valueGroup )
      .toArray( ValueType[]::new );
}

@Override
public File[] listFiles( File directory, final FilenameFilter filter )
{
  try ( Stream<Path> listing = Files.list( path( directory ) ) )
  {
    return listing
        .filter( entry -> filter.accept( entry.getParent().toFile(), entry.getFileName().toString() ) )
        .map( Path::toFile )
        .toArray( File[]::new );
  }
  catch ( IOException e )
  {
    return null;
  }
}

@Autowired
public VM(SystemProperties config, VMHook hook) {
  this.config = config;
  this.vmTrace = config.vmTrace();
  this.dumpBlock = config.dumpBlock();
  this.hooks = Stream.of(deprecatedHook, hook)
      .filter(h -> !h.isEmpty())
      .toArray(VMHook[]::new);
  this.hasHooks = this.hooks.length > 0;
}

public static Path[] listFiles(Path path, final Predicate<Path> filter) throws IOException {
 try (Stream<Path> list = Files.list(path)) {
  return list.filter(filter).toArray(Path[]::new);
 }
}

public DbTesterMyBatisConfExtension(Class<?> firstMapperClass, Class<?>... otherMapperClasses) {
 this.mapperClasses = Stream.concat(
  Stream.of(firstMapperClass),
  Arrays.stream(otherMapperClasses))
  .sorted(Comparator.comparing(Class::getName))
  .toArray(Class<?>[]::new);
}

public Type[] getRelationCoercion(Relation relation)
{
  return Optional.ofNullable(relationCoercions.get(NodeRef.of(relation)))
      .map(types -> types.stream().toArray(Type[]::new))
      .orElse(null);
}

@Override
public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
    throws SQLException
{
  Properties properties = new PrestoDriverUri(url, info).getProperties();
  return ConnectionProperties.allProperties().stream()
      .map(property -> property.getDriverPropertyInfo(properties))
      .toArray(DriverPropertyInfo[]::new);
}

@Override
public Page getNextPage()
{
  Page nextPage = delegate.getNextPage();
  if (nextPage == null) {
    return null;
  }
  Block[] blocks = Arrays.stream(delegateFieldIndex)
      .mapToObj(nextPage::getBlock)
      .toArray(Block[]::new);
  return new Page(nextPage.getPositionCount(), blocks);
}

public Resource[] resolveMapperLocations() {
  return Stream.of(Optional.ofNullable(this.mapperLocations).orElse(new String[0]))
    .flatMap(location -> Stream.of(getResources(location)))
    .toArray(Resource[]::new);
}

private String[] inclusions(Function<String, String[]> configProvider, String propertyKey) {
 return Arrays.stream(configProvider.apply(propertyKey))
  .map(StringUtils::trim)
  .filter(s -> !"**/*".equals(s))
  .filter(s -> !"file:**/*".equals(s))
  .toArray(String[]::new);
}

/**
 * Creates a classloader respecting the classpath option.
 *
 * @return the classloader.
 */
protected synchronized ClassLoader createClassloader() {
 URL[] urls = classpath.stream().map(path -> {
  File file = new File(path);
  try {
   return file.toURI().toURL();
  } catch (MalformedURLException e) {
   throw new IllegalStateException(e);
  }
 }).toArray(URL[]::new);
 return new URLClassLoader(urls, this.getClass().getClassLoader());
}

  private static TypeSerializer<?>[] snapshotsToRestoreSerializers(TypeSerializerSnapshot<?>... snapshots) {
    return Arrays.stream(snapshots)
        .map(TypeSerializerSnapshot::restoreSerializer)
        .toArray(TypeSerializer[]::new);
  }
}

public static String extractedDescriptionOf(Object... items) {
 String[] itemsDescription = Stream.of(items).map(Object::toString).toArray(String[]::new);
 return extractedDescriptionOf(itemsDescription);
}

public static ValueType[] including( Predicate<ValueType> include )
{
  return Arrays.stream( ValueType.values() )
      .filter( include )
      .toArray( ValueType[]::new );
}

private StoreType[] relevantRecordStores()
{
  return Stream.of( StoreType.values() )
      .filter( type -> type.isRecordStore() && type != StoreType.META_DATA ).toArray( StoreType[]::new );
}

private static String[] getFilteredKeys(URL url) {
  Map<String, String> params = url.getParameters();
  if (CollectionUtils.isNotEmptyMap(params)) {
    return params.keySet().stream()
        .filter(k -> k.startsWith(HIDE_KEY_PREFIX))
        .toArray(String[]::new);
  } else {
    return new String[0];
  }
}