Stream类的集合操作——一看就会

对集合list/set进行操作是非常常见的事情。我们可以使用Optional类来处理空指针问题（Optional操作可以参考Optional类判空操作）。之后对元素进行遍历，改变，排序等操作可以使用Stream类了。

Stream不是集合，也不保存数据，是用来操作集合里元素的，像一个高级版本的迭代器。Stream的方法分为中间方法和终结方法，中间方法依然会返回Stream，终结方法就相当于这个流的所有元素都已经消费完毕了，不会有后续操作了。

下面列出常见的方法使用

1、map 映射

map方法是中间方法。使用map会使每个元素都执行映射函数，一遍而言是希望对元素有所改变。若是不想改变元素，仅仅是使用元素的值，可以使用遍历foreach。

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

List<String> list = Lists.newArrayList();
list.add("qsm1");
list.add("qsm2");
list.add("qsm3");
list.add("hn1");
list.add("hn2");
list.add("hn3");
list.add("jd1");
list.add("jd2");

//map 中间操作
List<String> map1 = list.stream().map(s -> {
    if (s.startsWith("q")) {
        String substring = s.substring(0, 1);
        return substring;
    }
    return s;
}).collect(Collectors.toList());
System.out.println(map1);//[q, q, q, hn1, hn2, hn3, jd1, jd2]

List<String> tempMapList =Lists.newArrayList();
List<String> map2 = list.stream().map(s -> {
    if (s.startsWith("q")) {
        String substring = s.substring(0, 1);
        tempMapList.add(substring);
        return substring;
    }
    return s;
}).collect(Collectors.toList());
System.out.println(tempMapList);//[q, q, q]
System.out.println(map2);//[q, q, q, hn1, hn2, hn3, jd1, jd2]

2、foreach遍历

foreach 终止操作。注意：forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。

void forEach(Consumer<? super T> action);

tempMapList.clear();
list.stream().forEach(s -> tempMapList.add(Integer.toString(s.length())));
System.out.println(tempMapList);//[4, 4, 4, 3, 3, 3, 3, 3]

3、filter过滤

filter 过滤，只保留符合条件的元素; 中间操作

Stream<T> filter(Predicate<? super T> predicate);

list.stream().filter(s -> s.startsWith("q")).forEach(System.out::println);// qsm1 qsm2 qsm3
//list.stream().filter(s -> s.startsWith("a")).forEach(s -> System.out.println(s));

4、sorted排序

sorted之后, 原来list不会改变; 中间操作

Stream<T> sorted(Comparator<? super T> comparator);

list.stream().sorted(Comparator.comparingInt(String::length)).filter(s -> s.startsWith("j")).forEach(System.out::println);//jd1 jd2
List<String> collect = list.stream().sorted((a, b) -> a.length() - b.length()).filter(s -> s.contains("1")).collect(Collectors.toList());
System.out.println(collect);//[hn1, jd1, qsm1]
System.out.println(list);//[qsm1, qsm2, qsm3, hn1, hn2, hn3, jd1, jd2]

5、Match匹配

Match对所有元素进行匹配，是否满足条件。

boolean anyMatch(Predicate<? super T> predicate);

list.stream().anyMatch(s -> s.length() > 3);//true
list.stream().allMatch(s -> s.length() > 3);//false
list.stream().noneMatch(s -> s.length() > 3);//false

6、Reduce规约

Reduce 规约：多个元素规约为一个元素,identity为一个初始种子

Optional<T> reduce(BinaryOperator<T> accumulator);

Optional<String> reduce = list.stream().reduce((a, b) -> a + "->" + b);
String qsm = list.stream().reduce("qq", (a, b) -> a + "->" + b);
System.out.println(reduce.orElse(null));//qsm1->qsm2->qsm3->hn1->hn2->hn3->jd1->jd2
System.out.println(qsm);//qq->qsm1->qsm2->qsm3->hn1->hn2->hn3->jd1->jd2

【正在去BAT的路上修行】