Java核心技术：Java SE 8的流库——转换流

filter、map和flatMap方法

filter

filter转换可会产生一个流，它的元素与某种条件匹配。

// 将一个字符串流转换为只包含长单词的另一个流
List<String> wordList = ...;
Stream<String> longWords = wordList.stream().filter(w -> w.length() > 12);

filter的引元是Predicate<T>,即从T到boolean的函数。

map

可以使用map方法并传递执行转换的函数来实现按照某种方式转换流中的值。

// 产生一个包含所有单词的搜字母的流
Stream<String> lowercaseWords = words.stream().map(s -> s.substring(0, 1));

flatMap

假设在一个字符串上映射letters方法：

Stream<Stream<String>> result = words.stream().map(w -> letters(w));

public staic Stream<String> letters(String s) {
	List<String> result = new ArrayList();
	for (int i = 0; i < s.length(); i++) {
		resultadd(s.substring(i, i + 1);
	}
	return result.stream();

那么就会得到一个包含流的流，像[…[“y”, “0”, “u”, “r”], [“b”, “o”, “a”, “t”], …]。为了将其平摊为字母流[… “y”, “0”, “u”, “r”, “b”, “o”, “a”, “t”, …]，可以使用flatMap方法：

Stream<String> flatResult = words.stream().flatMap(w -> letters(w));

@RunWith(JUnit4.class)
public class TranslateStreamTest {
    private Stream<String> getStream() {
        String[] strings = {"first", "second", "three"};
        return Arrays.asList(strings).stream();
    }

    @Test
    public void testFlatMap() {
        FollowedUserTag followedUserTag = new FollowedUserTag("ljo224l242oj1");
        FollowedUser followedUser = new FollowedUser("szu_audi");
        followedUser.tags = Arrays.asList(followedUserTag);
        List<FollowedUser> followedUserList = Arrays.asList(followedUser);

        Stream<FollowedUserTag> userTagStream = followedUserList.stream().flatMap(item -> item.tags.stream());
    }

    private static class FollowedUser {
        public String remark;
        public List<FollowedUserTag> tags;

        public FollowedUser(String remark) {
            this.remark = remark;
        }
    }

    private static class FollowedUserTag {
        public String tagId;

        public FollowedUserTag(String tagId) {
            this.tagId = tagId;
        }
    }

}

抽取子流和连接流

调用Stream.limit(n)会返回一个新的流，它在n个元素之后结束(如果原来的流更短，那么就会在流结束时结束)。

Stream<Double> randoms = Stream.generate(Math::random).limit(100);

调用stream.skip(n)正好相反：他会丢弃前n个元素。

Stream<String> words = Stream.of(contents.split("\\PL+")).skip(1);

用Stream类的静态方法concat可以将两个流连接起来：

Stream<String> combined = Stream.concat(
	letters("Hello"), letters("World");
	// Yields the stream ["H, "e", "l", "l", "o", "W", "o", "r", "l", "d"]

其他的流转换

disinct方法会返回一个流，原来的元素按照同样的顺序剔除重复元素后产生。

Stream<String> uniqueWords = Stream.of("merrily", "merrily", "merrily", "gently").distinct();
// only one "merrily" is retained