Java Stream.empty方法代碼示例

import java.util.stream.Stream; //導入方法依賴的package包/類
@Override
public Stream<LookupElementBuilder> resolveCompletions(String propertyName, PsiType psiType) {
    PsiType[] parameters = ((PsiClassReferenceType) psiType).getParameters();
    Stream<PsiClass> psiClassStream = null;
    if (parameters.length == 1 && parameters[0] instanceof PsiWildcardType) {
        PsiWildcardType psiWildcardType = ((PsiWildcardType) parameters[0]);
        if (psiWildcardType.isBounded()) {
            if (psiWildcardType.isExtends()) {
                psiClassStream = subClasses((PsiClassType) psiWildcardType.getExtendsBound()).stream();
            } else if (psiWildcardType.isSuper()) {
                psiClassStream = superClasses((PsiClassType) psiWildcardType.getSuperBound()).stream();
            }
        }
    }
    if (psiClassStream != null) {
        return psiClassStream.map(this::buildClassLookup).filter(Optional::isPresent).map(Optional::get);
    } else {
        return Stream.empty();
    }
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
@Test
public void should_collect_flatmap_an_empty_stream_into_an_empty_stream() {

    // Given
    Stream<String> strings = Stream.empty();
    Function<String, Stream<Character>> flatMapper = string -> string.chars().mapToObj(letter -> (char)letter);
    Collector<String, ?, Stream<Character>> streamCollector = CollectorsUtils.flatMapping(flatMapper);

    // When
    List<Character> characters = strings.collect(streamCollector).collect(toList());

    // Then
    assertThat(characters).isEmpty();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
@SuppressWarnings("unchecked")
@Override
public <T extends Node> Stream<RNode<T>> css(String selector) {
	if (scene.getRoot() != null) {
		return scene.getRoot().lookupAll(selector).stream().map(v -> new RNodeImpl<>((T) v, this));
	}
	return Stream.empty();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
public static Stream<Polygon> polygonsFrom(Geometry g) {
    if (g instanceof Polygon) {
        return Stream.of((Polygon) g);
    }
    else if (g instanceof MultiPolygon) {
        Builder<Polygon> builder = Stream.builder();
        for (int i = 0; i < g.getNumGeometries(); i++) {
            builder.add((Polygon) g.getGeometryN(i));
        }
        return builder.build();
    }
    return Stream.empty();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
/**
 * Create a stream of files from a directory.
 *
 * @param dir The {@code File} that hopefully is a directory.
 * @return A stream of {@code File}s.
 */
public static Stream<File> fileStream(File dir) {
    File[] files;
    return (dir == null || !dir.isDirectory()
        || (files = dir.listFiles()) == null)
        ? Stream.<File>empty()
        : Arrays.stream(files);
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
private Stream<S3PropertiesFile> backingFiles() {
  if (s3 == null) {
    return Stream.empty();
  } else {
    Stream<S3PropertiesFile> stream = s3.listObjects(bucket, nodeAccess.getId()).getObjectSummaries().stream()
        .filter(summary -> summary.getKey().endsWith(METRICS_EXTENSION))
        .map(summary -> new S3PropertiesFile(s3, bucket, summary.getKey()));
    return stream;
  }
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
public static Stream<Activation> select(INeuron.ThreadState th, INeuron n, Integer rid, Range r, Range.Relation rr, InterprNode o, InterprNode.Relation or) {
    Stream<Activation> results;
    int s = th.activations.size();

    Node node = n.node.get();
    if(s == 0) return Stream.empty();
    else if(s == 1) {
        results = th.activations
                .values()
                .stream();
    } else if(rid != null) {
        Key bk = new Key(node, Range.MIN, rid, InterprNode.MIN);
        Key ek = new Key(node, Range.MAX, rid, InterprNode.MAX);

        if(th.activationsRid != null) {
            results = th.activationsRid.subMap(bk, true, ek, true)
                    .values()
                    .stream();
        } else return Stream.empty();
    } else {
        if(rr == null) {
            results = th.activations.values()
                    .stream();
        } else {
            return getActivationsByRange(th, n, rid, r, rr, o, or);
        }
    }

    return results.filter(act -> act.filter(node, rid, r, rr, o, or));
}
 

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包/類
/**
 * 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包/類
private Stream<ExecutionInterceptor> createExecutionInterceptorsFromResources(Enumeration<URL> resources) {
    if (resources == null) {
        return Stream.empty();
    }

    return Collections.list(resources).stream().flatMap(this::createExecutionInterceptorFromResource);
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
@Override
public Stream<String> list() {
    return Stream.empty();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
/**
 * {@inheritDoc}
 */
public final Stream<Scope> getScopes() {
    return (this.scopes == null) ? Stream.<Scope>empty()
        : this.scopes.stream();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
@Test (expected = NoSuchElementException.class)
public void firstThrowsIfEmptyConfig() {
    configValues = Stream.empty();
    this.first();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
/**
 * {@inheritDoc}
 */
public final Stream<Scope> getScopes() {
    return (this.scopes == null) ? Stream.<Scope>empty()
        : getScopeList().stream();
}
 

import java.util.stream.Stream; //導入方法依賴的package包/類
public static <T> Stream<T> conditional(boolean condition, Stream<T> stream) {
    return condition ? stream : Stream.empty();
}