Java Stream.flatMap方法代码示例

import java.util.stream.Stream; //导入方法依赖的package包/类
public Stream<ISemiBlock> getSemiBlocksInArea(World world, AxisAlignedBB aabb){
    List<Chunk> applicableChunks = new ArrayList<Chunk>();
    int minX = (int)aabb.minX;
    int minY = (int)aabb.minY;
    int minZ = (int)aabb.minZ;
    int maxX = (int)aabb.maxX;
    int maxY = (int)aabb.maxY;
    int maxZ = (int)aabb.maxZ;
    
    //Get the relevant chunks.
    for (int x = minX; x < maxX + 16; x += 16) {
        for (int z = minZ; z < maxZ + 16; z += 16) {
            Chunk chunk = world.getChunkFromBlockCoords(new BlockPos(x, 0, z));
            applicableChunks.add(chunk);
        }
    }
    
    //Retrieve all semi block storages from the relevant chunks
    Stream<Map<BlockPos, List<ISemiBlock>>> chunkMaps = applicableChunks.stream()
                                                                        .map(chunk -> getSemiBlocks().get(chunk))
                                                                        .filter(map -> map != null);
    
    Stream<List<ISemiBlock>> semiBlocksPerPos = chunkMaps.flatMap(map -> map.values().stream());
    Stream<ISemiBlock> existingSemiBlocksInArea = semiBlocksPerPos.flatMap(semiBlockLists -> semiBlockLists.stream());
    Stream<ISemiBlock> allSemiBlocksInArea = Streams.concat(existingSemiBlocksInArea, addingBlocks.stream());
    return allSemiBlocksInArea.filter(s -> !s.isInvalid() &&
                                           minX <= s.getPos().getX() && s.getPos().getX() <= maxX &&
                                           minY <= s.getPos().getY() && s.getPos().getY() <= maxY &&
                                           minZ <= s.getPos().getZ() && s.getPos().getZ() <= maxZ);
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
private Stream<Node> pluckDescendants(Node parent, TemplateId... path) {
	Stream<Node> tier = Stream.of(parent);
	for (TemplateId nextTier : Arrays.asList(path)) {
		tier = tier.flatMap(node -> node.getChildNodes(nextTier));
	}
	return tier;
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public static <T, X> Stream<T> lookupProvidedChildrenByTags(Stream<T> children, X tags, BiFunction<T, X, X> adjuster, BiFunction<T, X, Stream<T>> nodeToChildren) {
    Stream<T> result = children.flatMap(child -> {
        X adjustedTags = adjuster.apply(child, tags);
        Stream<T> subStream = lookupChildrenByTags(child, adjustedTags, adjuster, nodeToChildren);
        return subStream = Stream.concat(Stream.of(child), subStream);
    });
    return result;
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
/**
 * 中间操作(Intermediate) 转换Stream
 */
public static void middleStream(){
	System.err.println("----------------------------中间操作 转换Stream-----------------------------");
	
	//去除重复 distinct
	lists.stream().distinct().forEach(p -> System.out.print(p + "\t"));  //1	2	3	follow	wind	followwwind
	System.out.println();
	
	//过滤元素 filter
	lists.stream().filter(p -> p.length() > 1).forEach(p -> System.out.print(p + "\t")); //follow	wind	followwwind
	System.out.println();
	
	// sorted 流排序,中间操作返回流本身
	lists.stream().filter(str -> str.contains("w"))
	.sorted((str1, str2) -> {
		if (str1.length() == str2.length()) {
			return 0;	
		} else if (str1.length() > str2.length()) {
			return 1;
		} else {
			return -1;
		}
	}).forEach(System.out::println);  //wind follow followwwind	
	
	//limit 对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素；
	lists.stream().limit(5).forEach(p -> System.out.print(p + "\t")); //1	2	3	3	follow	
	System.out.println();
	
	//skip 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；
	lists.stream().skip(5).forEach(p -> System.out.print(p + "\t")); //wind	followwwind
	System.out.println();
	
	//peek 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；
	lists.stream().peek(p -> {p = p.toUpperCase(); System.out.println(p);}).forEach(System.out::println); 
	System.out.println();
	
	//转换元素 map
	lists.stream().map(p -> p + "-->").forEach(System.out::print); // 1-->2-->3-->3-->follow-->wind-->followwwind-->
	System.out.println("end");
	lists.stream().map(p -> p.split(" ")).map(p -> p[0] + "\t").forEach(System.out::print);//1	2	3	3	follow	wind	followwwind
	System.out.println();
	lists.stream().map(p -> p.split("")).map(p -> {
		String tmp = "";
		if(p.length > 1){
			tmp = p[1];
		}else{
			tmp = p[0];
		}
		return tmp + "\t";
	}).forEach(System.out::print); //1	2	3	3	o	i	o
	System.out.println();
	lists.stream().filter(p -> p.matches("\\d+")).mapToInt(p -> Integer.valueOf(p)).forEach(p -> System.out.print(p + "\t"));//1	2	3	3
	System.out.println();
	
	// flatMap 和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中
	lists.stream().flatMap(p -> Stream.of(p.split("www"))).forEach(p -> System.out.print(p + "\t"));
	//1	 2	3	3	follow	wind	follo	ind
	Stream<List<Integer>> inputStream = Stream.of(
		 Arrays.asList(1),
		 Arrays.asList(2, 3),
		 Arrays.asList(4, 5, 6)
	 );
	System.out.println();
	Stream<Integer> outputStream = inputStream.
	flatMap((childList) -> childList.stream());
	outputStream.forEach(p -> System.out.print(p + "\t")); //1	2	3	4	5	6
	System.out.println();
	System.err.println("----------------------------中间操作 转换Stream-----------------------------");
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
protected Stream<? extends BukkitFacetContext<?>> contexts(Object event) {
    // Try to get some online players from the event, either directly
    // through MatchPlayerEvent, or indirectly through entities.
    final Set<MatchPlayer> players;
    if(event instanceof MatchPlayerEvent) {
        players = ((MatchPlayerEvent) event).players().collect(Collectors.toImmutableSet());
    } else {
        final Set<Entity> entities = new HashSet<>();
        if(event instanceof EntityAction) entities.add(((EntityAction) event).getActor());
        if(event instanceof EntityEvent) entities.add(((EntityEvent) event).getEntity());
        if(event instanceof PlayerAction) entities.add(((PlayerAction) event).getActor());
        if(event instanceof PlayerEvent) entities.add(((PlayerEvent) event).getPlayer());

        players = entities.stream()
                          .flatMap(entity -> Streams.ofNullable(finder.getPlayer(entity)))
                          .collect(Collectors.toImmutableSet());
    }

    // If we have one or more MatchPlayers, return them along with their user contexts
    if(!players.isEmpty()) {
        return Stream.concat(
            players.stream(),
            players.stream().map(player -> player.userContext)
        );
    }

    // If we couldn't derive any online players from the event, try for offline player UUIDs
    final Set<UUID> uuids;
    if(event instanceof MatchUserEvent) {
        uuids = ((MatchUserEvent) event).users().collect(Collectors.toImmutableSet());
    } else if(event instanceof UserEvent) {
        uuids = ImmutableSet.of(((UserEvent) event).getUser().uuid());
    } else {
        return Stream.empty();
    }

    // Restrict to a specific match, if possible
    final Stream<Match> matches = finder.match((Event) event)
                                        .map(Stream::of)
                                        .orElseGet(() -> finder.currentMatches().stream());

    // Search the selected matches for both users and players
    // with the selected UUIDs.
    return matches.flatMap(
        match -> uuids.stream().flatMap(
            uuid -> Stream.concat(
                Optionals.stream(match.player(uuid)),
                Optionals.stream(match.userContext(uuid))
            )
        )
    );
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@Override
public Stream<Data<T>> upcast(Stream<Data<T>> input) {
    return input.flatMap(i -> Optional.ofNullable(upcasters.get(new DataRevision(i)))
            .map(upcaster -> upcast(upcaster.upcast(i)))
            .orElse(Stream.of(i)));
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
static Stream<String> diffResults(
    Case c,
    Stream<Map.Entry<int[], Map<String, String>>> expectedResults
) {
    return expectedResults
        .flatMap(exp -> {
            int[] comb = exp.getKey();
            Map<String, String> expected = exp.getValue();

            String src = expandTemplate(c, comb);
            Map<String, String> actual;
            try {
                try (TestClassLoader cl = compile(src)) {
                    actual = generateResult(c, cl);
                } catch (CompileException ce) {
                    return Stream.of(src + "\n" +
                                     "got compilation error: " + ce);
                }
            } catch (IOException ioe) {
                // from TestClassLoader.close()
                return Stream.of(src + "\n" +
                                 "got IOException: " + ioe);
            }

            if (actual.equals(expected)) {
                return Stream.empty();
            } else {
                Map<String, String> diff = new HashMap<>(expected);
                diff.entrySet().removeAll(actual.entrySet());
                return Stream.of(
                    diff.entrySet()
                        .stream()
                        .map(e -> "expected: " + e.getKey() + ": " +
                                  e.getValue() + "\n" +
                                  "  actual: " + e.getKey() + ": " +
                                  actual.get(e.getKey()) + "\n")
                        .collect(joining("\n", src + "\n\n", "\n"))
                );
            }
        });
}