stream流基本用法

package com.paic.stream;

import org.junit.Test;

import java.text.Collator;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 创建流
 * 串行流
 * strings.stream();
 * 并行流
 * strings.parallelStream();
 * 中间操作符:filter、distinct、limit、skip、map、flatMap、sorted
 * 终止操作符:anyMatch、allMatch、noneMatch、findAny、findFirst、forEach、collect、reduce.
 */
public class StreamTest {
    // ****************************中间操作符**************************************

    /**
     * filter:过滤集合中不符合条件的元素
     */
    @Test
    public void filter() {
        List<String> strings = Arrays.asList("aaa", "bbb", "ccc", "ddd");

        /**
         * 将集合转为流，在进行过滤，最后转成集合，不对之前的集合进行操作，产生的集合为新的集合
         */
        List<String> c = strings.stream().filter(str -> str.contains("c")).collect(Collectors.toList());
        System.out.println("c = " + c); // c = [ccc]
        System.out.println("strings = " + strings); // strings = [aaa, bbb, ccc, ddd]
    }

    /**
     * distinct:去重(比较的事元素的hashCode和equals方法实现)
     */
    @Test
    public void distinct() {
        List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
        List<String> collect = strings.stream().distinct().collect(Collectors.toList());
        System.out.println("collect = " + collect); // collect = [aaa, bbb, ccc, ddd]
        System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
        //-----------------------------------------------------------
        ArrayList<User> list = new ArrayList<>();
        list.add(new User(1, "z"));
        list.add(new User(1, "z"));
        list.add(new User(2, "s"));
        List<User> users = list.stream().distinct().collect(Collectors.toList());
        System.out.println("users = " + users);
        System.out.println("list = " + list);
    }

    /**
     * limit: 获取流中的指定元素前n个
     */
    @Test
    public void limit() {
        List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
        List<String> collect = strings.stream().limit(3).collect(Collectors.toList());
        System.out.println("collect = " + collect); // collect = [aaa, bbb, bbb]
        System.out.println("strings = " + strings); //strings = [aaa, bbb, bbb, ccc, ddd]
    }

    /**
     * skip: 获取流中除去前n个元素的其他所有元素
     */
    @Test
    public void skip() {
        List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
        List<String> collect = strings.stream().skip(3).collect(Collectors.toList());
        System.out.println("collect = " + collect); // collect = [ccc, ddd]
        System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
    }

    /**
     * map: 对流中所有元素做统一处理
     */
    @Test
    public void map() {
        List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
        List<Object> collect = strings.stream().map(str ->
                str.concat("_map")
        ).collect(Collectors.toList());
        System.out.println("collect = " + collect); // collect = [aaa_map, bbb_map, bbb_map, ccc_map, ddd_map]
        System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
    }

    /**
     * flatMap: 扁平化,把返回的流数组中的内容整合成一个流
     */
    @Test
    public void flatMap() {
        List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
        List<Character> collect = strings.stream().flatMap(str -> StreamTest.getCharacterByString(str)).collect(Collectors.toList());
        System.out.println("collect = " + collect); // collect = [a, a, a, b, b, b, b, b, b, c, c, c, d, d, d]
        System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
    }

    /**
     * map与flatMap 对比
     * 以下解析：
     * flatMap
     * （1） [a,a,a],[b,b,b],[b,b,b],[c,c,c],[d,d,d]
     * （2） [a,a,a,b,b,b,b,b,b,c,c,c,d,d,d]
     * <p>
     * <p>
     * map
     * （1） [a,a,a],[b,b,b],[b,b,b],[c,c,c],[d,d,d]
     */
    @Test
    public void flatMap___map() {
        List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
        Stream<Stream<Character>> streamMap = strings.stream().map(StreamTest::getCharacterByString);
        streamMap.forEach(s -> s.forEach(System.out::println)); // 遍历层级-2
        System.out.println("------------------------------");
        Stream<Character> streamFlatMap = strings.stream().flatMap(StreamTest::getCharacterByString);
        streamFlatMap.forEach(System.out::println); // 遍历层级-1
    }

    /**
     * sorted: 排序
     */
    @Test
    public void sorted() {
        // ***************************字母排序*************************************************
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        List<String> collect = strings.stream().sorted().collect(Collectors.toList());
        System.out.println("collect = " + collect); // collect = [aaa, bbb, ccc, dbb, ddd]
        System.out.println("strings = " + strings); // strings = [aaa, dbb, bbb, ccc, ddd]
        // ****************************数字排序***********************************************
        List<Integer> integers = Arrays.asList(1, 2, 3, 5, 6, 4, 5, 6, 7, 8, 9, 05, 534543, 664);
        List<Integer> integerList = integers.stream().sorted().collect(Collectors.toList());
        System.out.println("integers = " + integers); // integers = [1, 2, 3, 5, 6, 4, 5, 6, 7, 8, 9, 5, 534543, 664]
        System.out.println("integerList = " + integerList); // integerList = [1, 2, 3, 4, 5, 5, 5, 6, 6, 7, 8, 9, 664, 534543]
        // ****************************汉字排序***********************************************
        List<String> stringList = Arrays.asList("张三", "李四", "王五", "赵柳", "王小二");
        List<String> collect1 = stringList.stream().sorted().collect(Collectors.toList());
        System.out.println("collect1 = " + collect1); // collect1 = [张三, 李四, 王五, 王小二, 赵柳]
        // 汉字按字母顺序排序
        List<String> collect2 = stringList.stream().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());
        System.out.println("collect2 = " + collect2); // collect2 = [李四, 王五, 王小二, 张三, 赵柳]

    }

    // 字符串转换成字符流
    public static Stream<Character> getCharacterByString(String str) {
        ArrayList<Character> list = new ArrayList<>();
        for (Character character : str.toCharArray()) {
            list.add(character);
        }
        return list.stream();
    }

    // *******************************终止操作符********************************************

    /**
     * anyMatch: 检查是否至少匹配一个元素，返回Boolean
     */
    @Test
    public void anyMatch() {
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        boolean b = strings.stream().anyMatch(s -> s.contains("b/"));
        boolean b1 = strings.stream().anyMatch(s -> s.contains("b"));
        System.out.println("b = " + b); // b = false
        System.out.println("b1 = " + b1); // b1 = true
    }

    /**
     * allMatch: 集合中元素是否都满足条件
     */
    @Test
    public void allMatch() {
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        boolean b = strings.stream().allMatch(s -> s.length() > 0);
        boolean b1 = strings.stream().allMatch(s -> s.contains("a"));
        System.out.println("b = " + b); // b = true
        System.out.println("b1 = " + b1); // b1 = false
    }

    /**
     * allMatch: 集合中元素是否都不满足条件
     */
    @Test
    public void noneMatch() {
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        boolean b = strings.stream().noneMatch(s -> s.length() > 0);
        boolean b1 = strings.stream().noneMatch(s -> s.contains("f"));
        System.out.println("b = " + b); // b = false
        System.out.println("b1 = " + b1); // b1 = true
    }

    /**
     * findAny: 返回集合中任意元素
     */
    @Test
    public void findAny() {
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        Optional<String> any = strings.stream().findAny();
        if (any.isPresent())  // 判断是否存在
            System.out.println(any.get()); // aaa

    }

    /**
     * findFirst: 返回集合中第一个元素
     */
    @Test
    public void findFirst() {
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        Optional<String> any = strings.stream().findFirst();
        if (any.isPresent())  // 判断是否存在
            System.out.println(any.get()); // aaa

    }

    /**
     * forEach: 循环/遍历流
     */
    @Test
    public void forEach() {
        List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
        strings.stream().forEach(System.out::println);
        strings.stream().forEach(s -> System.out.println(s));
    }

    /**
     * collect: 收集器，将流转换成其他形式
     */
    @Test
    public void collect() {
        List<String> strings = Arrays.asList("aaa", "dbb", "aaa", "ccc", "ddd");
        strings.stream().collect(Collectors.toSet()); // 转换成set集合
        strings.stream().collect(Collectors.toList()); // 转换成List集合

//        // ***************************************************
//        Map<String, String> collect = strings.stream().collect(Collectors.toMap(v -> v, v -> v));// 转换成map集合,将list中的每一个元素当做key和value，但是当key重复是会报错   java.lang.IllegalStateException: Duplicate key aaa
//        System.out.println("collect = " + collect);

        Map<String, String> collect1 = strings.stream().collect(Collectors.toMap(v -> v, v -> v, (oldValue, newValue) -> newValue));// 转换成map集合,将list中的每一个元素当做key和value,但是当key重复是取newValue(调用了 return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;)
        System.out.println("collect1 = " + collect1);
    }

    /**
     * reduce: 可以将元素反复结合起来，得到一个值
     */
    @Test
    public void reduce(){
        List<String> strings = Arrays.asList("aaa", "dbb", "aaa", "ccc", "ddd");
        /**
         * acc : 计算结果
         * item : 每一个元素
         * -> 计算规则
         */
        Optional<String> reduce = strings.stream().reduce((acc, item) -> acc + item);
        // 此时给定一个初始结果，结果会与初始结果共同进行规则计算
        String reduce1 = strings.stream().reduce("aaa",(acc, item) -> (acc + item).replace("a",""));
        if (reduce.isPresent())
            System.out.println(reduce.get()); // aaadbbaaacccddd
        System.out.println("reduce1 = " + reduce1); // reduce1 = dbbcccddd
    }


    /**
     * count: 返回流中的元素总数
     */
    @Test
    public void count(){
        List<String> strings = Arrays.asList("aaa", "dbb", "aaa", "ccc", "ddd");
        long count = strings.stream().count();
        System.out.println("count = " + count);


    }
}