Java Stream.concat方法代码示例

import java.util.stream.Stream; //导入方法依赖的package包/类
Stream<Assignment> allPossible() throws Throwable {

        final List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(DataProducer.class);


        Stream<Assignment> methodAssignments = Stream.empty();
        for (FrameworkMethod annotatedMethod : annotatedMethods) {
            final Type methodReturnType = getMethodGenericReturnType(annotatedMethod.getMethod());
            methodAssignments = Stream.concat(methodAssignments, methodToStreamOfResults(annotatedMethod)
                    .map(value -> new MethodResultAssignment(value, methodReturnType, annotatedMethod)));
        }

        final List<FrameworkField> annotatedFields = testClass.getAnnotatedFields(DataProducer.class);
        final Stream<Assignment> fieldsAssignments = annotatedFields.stream()
                .map(FieldAssignment::new);
        return Stream.concat(fieldsAssignments, methodAssignments);
    }
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@Test
public void providersForServices() throws Throwable {
    if (!hasJmods()) return;

    List<String> output =
        JLink.run("--module-path", MODULE_PATH,
                  "--suggest-providers",
                  "java.nio.charset.spi.CharsetProvider,p1.S").output();

    System.out.println(output);
    Stream<String> expected = Stream.concat(
        Stream.of("jdk.charsets provides java.nio.charset.spi.CharsetProvider used by java.base"),
        Stream.of("m1 provides p1.S used by m1",
                  "m2 provides p1.S used by m1")
    );

    assertTrue(output.containsAll(expected.collect(Collectors.toList())));
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
/** Returns the fully qualified setting names contained in this settings object. */
public Set<String> keySet() {
    synchronized (keys) {
        if (keys.get() == null) {
            if (secureSettings == null) {
                keys.set(settings.keySet());
            } else {
                Stream<String> stream = Stream.concat(settings.keySet().stream(), secureSettings.getSettingNames().stream());
                // uniquify, since for legacy reasons the same setting name may exist in both
                keys.set(Collections.unmodifiableSet(stream.collect(Collectors.toSet())));
            }
        }
    }
    return keys.get();
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public Stream<ResultNode> stream() {
	if (isContainer()) {
		return Stream.concat(Stream.of(this), children.stream().flatMap((child) -> {
			return child.stream();
		}));
	}
	return Stream.of(this);
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@Override
default <R extends Filterable<?>> Stream<? extends R> filterableDescendants(Class<R> type) {
    Stream<R> result = Stream.of();
    if(type.isAssignableFrom(Match.class)) {
        result = Stream.concat(result, Stream.of((R) this));
    }
    if(Party.class.isAssignableFrom(type)) {
        result = Stream.concat(result, Streams.instancesOf(parties(), type));
    }
    if(type.isAssignableFrom(MatchPlayer.class)) {
        result = Stream.concat(result, (Stream<? extends R>) players());
    }
    return result;
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
/**
 * Concatenate streams.
 *
 * @param <T> Generic type of {@link Stream}
 * @param s0 The first {@code Stream}.
 * @param streams The {@code Stream}s to concatenate (nulls ignored).
 * @return The concatenated stream.
 */
@SafeVarargs
public static <T> Stream<T> concat(Stream<T> s0, Stream<T>... streams) {
    Stream<T>[] sts = streams;
    Stream<T> ret = (s0 == null) ? Stream.empty() : s0;
    for (int i = 0; i < sts.length; i++) {
        if (sts[i] != null) ret = Stream.concat(ret, sts[i]);
    }
    return ret;
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@Override
public Stream<? extends CypherAstBase> getChildren() {
    return Stream.concat(
            returnItems.stream(),
            Stream.of(order, limit, skip)
    );
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
/**
 * Returns a stream of all the member fields for the specified class,
 * including inherited fields from any ancestors. This includes public,
 * private, protected and package private fields.
 *
 * @param clazz  the class to traverse
 * @return       stream of fields
 */
public static Stream<Field> traverseFields(Class<?> clazz) {
    final Class<?> parent = clazz.getSuperclass();
    final Stream<Field> inherited;

    if (parent != null) {
        inherited = traverseFields(parent);
    } else {
        inherited = Stream.empty();
    }

    return Stream.concat(inherited, Stream.of(clazz.getDeclaredFields()));
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public Stream<TreeNode> lazyStream() {
    if (isLeaf()) {
        return Stream.of(this);
    } else {
        return Stream.concat(Stream.of(this), getChildren().stream().flatMap(TreeNode::stream));
    }
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public static Method[] getMethodsUpToJpaOdataEntity(Class<?> firstClass) {
    Stream<Method> result = Stream.of(firstClass.getDeclaredMethods());
    Class<?> superclass = firstClass.getSuperclass();
    if (!isLastClass(superclass)) {
        result = Stream.concat(result, Stream.of(getMethodsUpToJpaOdataEntity(superclass)));
    }
    return result.toArray(Method[]::new);
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@SafeVarargs
private final Stream<String> concatStreams(final Stream<String>... streams) {
    if (streams.length == 0)
        throw new IllegalArgumentException("No stream provided");

    Stream<String> currentStream = streams[0];
    for (Integer i = 1; i < streams.length; i++) {
        currentStream = Stream.concat(currentStream, streams[i]);
    }
    return currentStream;
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
/**
 * Return all individual objects of the given Filterable subtype that this object is composed of,
 * directly or indirectly, possibly including this object itself.
 *
 * This method simply tests this object's type, and recurses on all {@link #filterableChildren()}.
 * Subclasses should provide a more efficient implementation, if possible.
 */
default <R extends Filterable<?>> Stream<? extends R> filterableDescendants(Class<R> type) {
    Stream<? extends R> result = filterableChildren().flatMap(child -> child.filterableDescendants(type));
    if(type.isInstance(this)) {
        result = Stream.concat(Stream.of((R) this), result);
    }
    return result;
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public static Stream<Field> fields(Class<?> cls) {
  return Stream.concat(
      Arrays.stream(cls.getFields()),
      Arrays.stream(cls.getDeclaredFields())
          .filter(Util::notPublic)
  );
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@Override
public Stream<? extends Kit> dependencies() {
    return Stream.concat(parents.stream(), kits.dependencies());
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public static <T> Stream<T> reachableNodes(T node, Function<T, Stream<T>> nodeToChildren) {
    Stream<T> result = Stream.concat(
            Stream.of(node),
            nodeToChildren.apply(node).flatMap(v -> reachableNodes(v, nodeToChildren)));
    return result;
}