How to use

StreamUtils

in

org.springframework.data.util

public static List<Object> toIds(Collection<Document> documents) {
  return documents.stream()//
      .map(it -> it.get(ID_FIELD))//
      .collect(StreamUtils.toUnmodifiableList());
}

@Override
public Stream<T> stream() {
  return StreamUtils.createStreamFromIterator(doStream());
}

/**
 * Creates a new {@link JpaMetamodel} for the given JPA {@link Metamodel}.
 *
 * @param metamodel must not be {@literal null}.
 */
private JpaMetamodel(Metamodel metamodel) {
  Assert.notNull(metamodel, "Metamodel must not be null!");
  this.metamodel = metamodel;
  this.managedTypes = Lazy.of(() -> metamodel.getManagedTypes().stream() //
      .map(ManagedType::getJavaType) //
      .filter(it -> it != null) //
      .collect(StreamUtils.toUnmodifiableSet()));
}

@Override
public <S extends T> List<S> insert(Iterable<S> entities) {
  Assert.notNull(entities, "The given Iterable of entities not be null!");
  List<S> list = Streamable.of(entities).stream().collect(StreamUtils.toUnmodifiableList());
  if (list.isEmpty()) {
    return list;
  }
  return new ArrayList<>(mongoOperations.insertAll(list));
}

@SuppressWarnings("unchecked")
private List<Revision<N, T>> toRevisions(Map<N, T> source, Map<Number, Object> revisionEntities) {
  return source.entrySet().stream() //
      .map(entry -> Revision.of( //
          (RevisionMetadata<N>) getRevisionMetadata(revisionEntities.get(entry.getKey())), //
          entry.getValue())) //
      .sorted() //
      .collect(StreamUtils.toUnmodifiableList());
}

  @Override
  @SuppressWarnings("null")
  public int compare(PersistentPropertyPath<?> left, PersistentPropertyPath<?> right) {
    Function<PersistentProperty<?>, Integer> mapper = it -> it.getName().length();
    Stream<Integer> leftNames = left.stream().map(mapper);
    Stream<Integer> rightNames = right.stream().map(mapper);
    return StreamUtils.zip(leftNames, rightNames, (l, r) -> l - r) //
        .filter(it -> it != 0) //
        .findFirst() //
        .orElse(0);
  }
}

  /**
   * Obtains all {@link Metamodel} instances of the current {@link ApplicationContext}.
   *
   * @return
   */
  private Set<Metamodel> getMetamodels() {

    if (beanFactory == null) {
      throw new IllegalStateException("BeanFactory must not be null!");
    }

    Collection<EntityManagerFactory> factories = BeanFactoryUtils
        .beansOfTypeIncludingAncestors(beanFactory, EntityManagerFactory.class).values();

    return factories.stream() //
        .map(EntityManagerFactory::getMetamodel) //
        .collect(StreamUtils.toUnmodifiableSet());
  }
}

@Override
public Collection<T> findAllById(Iterable<ID> ids) {
  List<ID> keys = Streamable.of(ids).stream().collect(StreamUtils.toUnmodifiableList());
  return CollectionUtils.<ID, T>nullSafeMap(this.template.getAll(keys)).values().stream()
    .filter(Objects::nonNull).collect(Collectors.toList());
}

/**
 * Only provides types that are also annotated with {@link Table}.
 */
@Override
public Iterable<? extends TypeInformation<?>> getPersistentEntityTypes() {
  return StreamUtils
      .createStreamFromIterator(super.getPersistentEntityTypes().iterator())
      .filter((typeInfo) -> typeInfo.getType().isAnnotationPresent(Table.class))
      .collect(Collectors.toList());
}

  @Override
  public Set<MethodMetadata> getMethods(String name) {
    Assert.hasText(name, "Method name must not be null or empty");
    return methodMetadataSet.stream() //
        .filter(it -> it.getMethodName().equals(name)) //
        .collect(StreamUtils.toUnmodifiableSet());
  }
}

/**
 * Creates a new {@link Revisions} instance using the given revisions.
 *
 * @param revisions must not be {@literal null}.
 * @param latestLast
 */
private Revisions(List<? extends Revision<N, T>> revisions, boolean latestLast) {
  Assert.notNull(revisions, "Revisions must not be null!");
  this.revisions = revisions.stream()//
      .sorted(latestLast ? NATURAL_ORDER : NATURAL_ORDER.reversed())//
      .collect(StreamUtils.toUnmodifiableList());
  this.latestLast = latestLast;
}

/**
 * Returns {@link PropertyDescriptor}s for all properties exposed by the given type and all its super interfaces.
 *
 * @return
 */
List<PropertyDescriptor> getDescriptors() {
  return collectDescriptors().distinct().collect(StreamUtils.toUnmodifiableList());
}

/**
 * Returns an unmodifiable {@link Set} of all underlying {@link HttpMethod}s.
 * 
 * @return
 */
default Set<HttpMethod> toSet() {
  return stream().collect(StreamUtils.toUnmodifiableSet());
}

private MultiValueMap<NameAndArgumentCount, Function> getFunctions(Object target) {
  return methods.stream().collect(toMultiMap(NameAndArgumentCount::of, m -> new Function(m, target)));
}

private Stream<String> getColumnNameStream(String prefix) {
  return StreamUtils.createStreamFromIterator(entity.iterator()) //
      .flatMap(p -> getColumnNameStream(p, prefix));
}

/**
 * Returns a {@link Stream} backed by the given {@link CloseableIterator} and forwarding calls to
 * {@link Stream#close()} to the iterator.
 *
 * @param iterator must not be {@literal null}.
 * @return
 * @since 2.0
 */
public static <T> Stream<T> createStreamFromIterator(CloseableIterator<T> iterator) {
  Assert.notNull(iterator, "Iterator must not be null!");
  return createStreamFromIterator((Iterator<T>) iterator).onClose(() -> iterator.close());
}

@Override
public <S extends T> Flux<S> insert(Iterable<S> entities) {
  Assert.notNull(entities, "The given Iterable of entities must not be null!");
  List<S> source = Streamable.of(entities).stream().collect(StreamUtils.toUnmodifiableList());
  return source.isEmpty() ? Flux.empty() : Flux.from(mongoOperations.insertAll(source));
}

  /**
   * Obtains all {@link Metamodel} instances of the current {@link ApplicationContext}.
   *
   * @return
   */
  private Set<Metamodel> getMetamodels() {

    if (beanFactory == null) {
      throw new IllegalStateException("BeanFactory must not be null!");
    }

    Collection<EntityManagerFactory> factories = BeanFactoryUtils
        .beansOfTypeIncludingAncestors(beanFactory, EntityManagerFactory.class).values();

    return factories.stream() //
        .map(EntityManagerFactory::getMetamodel) //
        .collect(StreamUtils.toUnmodifiableSet());
  }
}

@Override
public Collection<T> findAllById(Iterable<ID> ids) {
  List<ID> keys = Streamable.of(ids).stream().collect(StreamUtils.toUnmodifiableList());
  return CollectionUtils.<ID, T>nullSafeMap(this.template.getAll(keys)).values().stream()
    .filter(Objects::nonNull).collect(Collectors.toList());
}

/**
 * Only provides types that are also annotated with {@link Table}.
 */
@Override
public Iterable<? extends TypeInformation<?>> getPersistentEntityTypes() {
  return StreamUtils
      .createStreamFromIterator(super.getPersistentEntityTypes().iterator())
      .filter((typeInfo) -> typeInfo.getType().isAnnotationPresent(Table.class))
      .collect(Collectors.toList());
}