JAVA Stream流精简教程

概念：

Stream是jdk8 API的成员， 它允许声明性方式处理数据集合。

特点：
（1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口告别for循环
（2）多核友好：Java函数式编程使得编写并行程序更简单， 你需要的全部就是调用一下方法。

流程：
(1) 第一步：把集合转换为stream
(2) 第二部：操作stream流
stream流在管道中经过中间操作（intermediate operation）处理，
最后由最终操作（terminal operation)得到前面处理的结果

Stream操作符：
两种操作符：中间操作符， 终止操作符。

--------------------------中间操作符-------------------------------

filter	用于通过设置的条件过滤出元素

@Test
    public void filter(){
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
//                                                                (collect)收集流元素  (Collectors.toList())再把流元素转换成LIst集合
        List<String> f = strings.parallelStream().filter(str -> str.contains("f")).collect(Collectors.toList());//用于通过设置的条件过滤出元素
        System.out.println(f);
    }

limit	会返回一个不超过给定长度的流

@Test
public void limite(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl", "jkl");
    List<String> collect = strings.stream().limit(3).collect(Collectors.toList());//只显示前三个数据
    System.out.println(collect);
}

skip	返回一个除去前面的n个元素的流

@Test
public void skip(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl", "jkl");
    List<String> collect = strings.stream().skip(3).collect(Collectors.toList()); //除了前三个后面的都显示
    System.out.println(collect);
}

map	接受一个函数作为参数。这个函数会被应用到每个元素上。并将其映射成一个新的元素

@Test
public void map(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl", "jkl");
    List<String> collect = strings.stream().map(str -> str.concat("_这是我加的后缀")).collect(Collectors.toList());
    collect.forEach(System.out::println);
}
输出结果：
abc_这是我加的后缀
_这是我加的后缀
bc_这是我加的后缀
efg_这是我加的后缀
abcd_这是我加的后缀
_这是我加的后缀
jkl_这是我加的后缀
jkl_这是我加的后缀

//同时添加前缀的方法如下
List<String> collect = strings.stream().map(str -> "这是我加的前缀_"+str).collect(Collectors.toList());

输出结果：
这是我加的前缀_abc
这是我加的前缀_
这是我加的前缀_bc
这是我加的前缀_efg
这是我加的前缀_abcd
这是我加的前缀_
这是我加的前缀_jkl
这是我加的前缀_jkl

flatMap	使用flatMap方法的效果是，各个数组并不是分别映射成流的内容， 而是映射成流的内容。所有使用map（Arrays::stream）时生成的单个流都被合并起来,既扁平化为一个流 大白话就是把多个Stream流转换为一个流

 @Test
public void flatMap(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl", "jkl");
        List<Character> collect = strings.stream().flatMap(str -> heima.getCharacterByString(str)).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

/**
 * 功能描述:把字符串转换为字节流
 * @param str
 * @return
 */
public static Stream<Character> getCharacterByString(String str){
    List<Character> characterList = new ArrayList<>();
    for (Character character : str.toCharArray()) {
        characterList.add(character);
    }
    return characterList.stream();
}

sorted	返回排序后的流

@Test
public void sorted(){
    List<String> strings = Arrays.asList("c", "f", "e", "p", "a", "b");
    List<String> collect = strings.stream().sorted().collect(Collectors.toList());
    System.out.println(collect);
}
//输出结果:  [a, b, c, e, f, p]

小结:
map:对流中每一个元素进行处理
flatMap:流扁平化,让你把一个流中的"每个值"都换成另一个流, 然后把所有的流连接起来成为一个流
总结:map是对一级元素进行操作, flatmap是对二级元素操作

-----------------------------终止符操作------------------------------

anyMatch	检查是否至少匹配一个元素，返回Boolean

@Test
public void anyMatch(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl", "jkl");
    boolean bc = strings.stream().anyMatch(s -> s.contains("bc")); //contains("bc")上述集合当中是否包含bc
    System.out.println(bc);
}
//输出结果:true

allMatch	检查是否匹配所有元素,返回boolean

@Test
public void allMatch(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    boolean bc = strings.stream().allMatch(s -> s.length()>0); //检查所有元素的长度是否都>0
    System.out.println(bc);
}
// 输出结果:true

noteMatch	检查是否没有匹配所有元素,返回值为boolean

@Test
public void noneMatch(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    boolean bc = strings.stream().noneMatch(s -> s.length()>5);//检查所有元素是否都不>5
    System.out.println(bc);
}
// 输出结果:true

findAny	将返回当前流的任意元素

@Test
public void findAny(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    Optional<String> any = strings.parallelStream().findAny();//这里如果用stream（串行流）只会输出一个“abc”, 所以使用并行流
    if (any.isPresent()) {
        System.out.println(any.get());
    }
}

findFirst	返回第一个元素

@Test
public void findFirst(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    Optional<String> any = strings.stream().findFirst();
    if (any.isPresent()) {
        System.out.println(any.get());
    }
}

forEach	遍历流

@Test
public void foreach(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    strings.forEach(e->System.out.println(e));//第一中方法
    strings.forEach(System.out::println);//第二中方法
}

collect	收集器将流转换为其他形式的流

@Test
public void collect(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    Set<String> collect = strings.stream().collect(Collectors.toSet()); //set集合无序, 不重复
    collect.forEach(System.out::println);
    //输出结果: bc,abc,efg,jkl,abcd
    Map<String, String> collect1 = strings.stream().collect(Collectors.toMap(v -> "key_"+v, v -> "value"+v, (oldvalue, newvalue) -> newvalue));
    System.out.println(collect1);
	}

reduce	可以将流中元素反复结合起来， 得到一个值

@Test
public void reduce(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    //                    计算的结果（acc），item选项代表上面的值                              把a替换为“ ”
    Optional<String> reduce = strings.stream().reduce((acc, item) -> { return (acc + item).replace("a",""); });
    if (reduce.isPresent()) {
        System.out.println(reduce.get());
    }
    //输出结果：bcbcefgbcdjkljkl
}

count	返回流中元素总数

@Test
public void count(){
    List<String> strings = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "jkl");
    long count = strings.stream().count();
    System.out.println(count);
}

注 : 以上代码, 如果你是新手,建议跟着敲一遍,要不然理解的会很片面 !