How to use

flatMap

method

in

java.util.stream.Stream

private List<MediaType> getMediaTypes(List<View> views) {
  return views.stream()
      .flatMap(view -> view.getSupportedMediaTypes().stream())
      .collect(Collectors.toList());
}

  public static <K, V> Map<K, V> mergeMaps(Stream<Map<K, V>> mapStream, BinaryOperator<V> merger)
  {
    return mapStream
        .map(Map::entrySet)
        .flatMap(Collection::stream)
        .collect(toMap(Map.Entry::getKey, Map.Entry::getValue, merger));
  }
}

private static Stream<Method> methodsStream( List<Class<?>> interfaces )
{
  return interfaces.stream().map( Class::getMethods ).flatMap( Arrays::stream );
}

@Override
public List<Symbol> getOutputSymbols()
{
  return ImmutableList.<Symbol>builder()
      .addAll(groupingSets.stream()
          .flatMap(Collection::stream)
          .collect(toSet()))
      .addAll(aggregationArguments)
      .add(groupIdSymbol)
      .build();
}

Stream<SegmentWithState> getAppendingSegments(Collection<String> sequenceNames)
{
 synchronized (segments) {
  return sequenceNames
    .stream()
    .map(segments::get)
    .filter(Objects::nonNull)
    .flatMap(segmentsForSequence -> segmentsForSequence.intervalToSegmentStates.values().stream())
    .map(segmentsOfInterval -> segmentsOfInterval.appendingSegment)
    .filter(Objects::nonNull);
 }
}

public Collection<Server> getAllServers()
{
 return ((Collection<List<Server>>) hostSelector.getAllBrokers().values()).stream()
                                      .flatMap(Collection::stream)
                                      .collect(Collectors.toList());
}

public Set<File> idFiles()
{
  return Arrays.stream( DatabaseFile.values() )
         .filter( DatabaseFile::hasIdFile )
        .flatMap( value -> Streams.ofOptional( idFile( value ) ) )
         .collect( Collectors.toSet() );
}

/**
 * Gets a stream of values from a collection of range resources.
 */
public static LongStream rangeValues(Collection<Protos.Resource> resources) {
  checkNotNull(resources);
  return resources.stream()
    .filter(Protos.Resource::hasRanges)
    .flatMap(r -> r.getRanges().getRangeList().stream())
    .flatMapToLong(Utils::rangeValues);
}

  @Override
  public void validate(PlanNode plan, Session session, Metadata metadata, SqlParser sqlParser, TypeProvider types, WarningCollector warningCollector)
  {
    searchFrom(plan)
        .where(AggregationNode.class::isInstance)
        .<AggregationNode>findAll()
        .stream()
        .flatMap(node -> node.getAggregations().values().stream())
        .filter(aggregation -> aggregation.getCall().getFilter().isPresent())
        .forEach(ignored -> {
          throw new IllegalStateException("Generated plan contains unimplemented filtered aggregations");
        });
  }
}

@Override
protected void applyCookies() {
  getCookies().values().stream().flatMap(Collection::stream)
      .map(cookie -> new DefaultCookie(cookie.getName(), cookie.getValue()))
      .forEach(this.request::addCookie);
}

/**
 * Create a new {@link MockMultipartHttpServletRequest} based on the
 * supplied {@code ServletContext} and the {@code MockMultipartFiles}
 * added to this builder.
 */
@Override
protected final MockHttpServletRequest createServletRequest(ServletContext servletContext) {
  MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest(servletContext);
  this.files.stream().forEach(request::addFile);
  this.parts.values().stream().flatMap(Collection::stream).forEach(request::addPart);
  if (!this.parts.isEmpty()) {
    new StandardMultipartHttpServletRequest(request)
        .getMultiFileMap().values().stream().flatMap(Collection::stream)
        .forEach(request::addFile);
  }
  return request;
}

private Stream<CompilationMessage> findDuplicates( Collection<Element> visitedProcedures )
{
  return indexByName( visitedProcedures ).filter( index -> index.getValue().size() > 1 )
      .flatMap( this::asErrors );
}

@Override
public List<Expression> getExpressions()
{
  return sets.stream()
      .flatMap(List::stream)
      .collect(Collectors.toList());
}

public static List<? extends SqlFunction> extractFunctions(Collection<Class<?>> classes)
{
  return classes.stream()
      .map(FunctionExtractor::extractFunctions)
      .flatMap(Collection::stream)
      .collect(toImmutableList());
}

public MultiJoinNode(LinkedHashSet<PlanNode> sources, Expression filter, List<Symbol> outputSymbols)
{
  requireNonNull(sources, "sources is null");
  checkArgument(sources.size() > 1, "sources size is <= 1");
  requireNonNull(filter, "filter is null");
  requireNonNull(outputSymbols, "outputSymbols is null");
  this.sources = sources;
  this.filter = filter;
  this.outputSymbols = ImmutableList.copyOf(outputSymbols);
  List<Symbol> inputSymbols = sources.stream().flatMap(source -> source.getOutputSymbols().stream()).collect(toImmutableList());
  checkArgument(inputSymbols.containsAll(outputSymbols), "inputs do not contain all output symbols");
}

/**
 * Returns initial {@link Method} as well as all matching ones found in interfaces.
 * This allows to introspect metadata for a method which is both declared in parent class and in implemented
 * interface(s). <code>interfaces</code> typically is obtained by {@link ClassUtils#getAllInterfacesAsSet}
 */
Collection<Method> getMethodAndInterfaceDeclarations(Method method, Collection<Class> interfaces) {
  final List<Method> methods = new ArrayList<>();
  methods.add(method);
  // we search for matching method by iteration and comparison vs getMethod to avoid repeated NoSuchMethodException
  // being thrown, while interface typically only define a few set of methods to check.
  interfaces.stream()
      .map(Class::getMethods)
      .flatMap(Arrays::stream)
      .filter(m -> m.getName().equals(method.getName()) && Arrays.equals(m.getParameterTypes(), method.getParameterTypes()))
      .findFirst()
      .ifPresent(methods::add);
  return methods;
}

@Override
public void upgrade() {
  this.indexSetService.findAll()
    .stream()
    .map(mongoIndexSetFactory::create)
    .flatMap(indexSet -> getReopenedIndices(indexSet).stream())
    .map(indexName -> { LOG.debug("Marking index {} to be reopened using alias.", indexName); return indexName; })
    .forEach(indices::markIndexReopened);
}

private List<DataSegment> getAvailableDataSegments()
{
 return metadataSegmentManager.getDataSources()
                .stream()
                .flatMap(source -> source.getSegments().stream())
                .collect(Collectors.toList());
}

@Override
protected void applyCookies() {
  getCookies().values().stream().flatMap(Collection::stream)
      .map(cookie -> new HttpCookie(cookie.getName(), cookie.getValue()))
      .forEach(this.jettyRequest::cookie);
}

public synchronized List<T> handlers() {
 return handlerMap.values().stream()
  .flatMap(handlers -> handlers.list.stream())
  .map(holder -> holder.handler)
  .collect(Collectors.toList());
}