Stream流的简单应用

一、Stream流的三种创建方式

1.1Collection.stream（）方法用集合创建

@Test
    public void method01() {
        int[] ints = {1,2,3,4,5,6,7,8};
        //创建Stream流
        IntStream stream = Arrays.stream(ints);
        OptionalInt max = stream.max();
        System.out.println(max.getAsInt());
        IntStream stream2 = Arrays.stream(ints);
        OptionalInt min = stream2.min();
        System.out.println(min.getAsInt());
        //max()和min()是终端操作，执行完之后Stream就关闭了

        double[] doubles = {1.2,3.4,5.6,7.8};
        DoubleStream stream1 = Arrays.stream(doubles);
        OptionalDouble max1 = stream1.max();
        System.out.println(max1.getAsDouble());

        long[] longs = {12L,32L,56L,78L};
        LongStream stream3 = Arrays.stream(longs);
        OptionalLong max2 = stream3.max();
        System.out.println(max2.getAsLong());

        Float[] floats = {1.2f,3.4f,5.6f,6.7f};
        Stream<Float> stream4 = Arrays.stream(floats);

        User[] users = {new User("张三"),new User("李四")};
        Stream<User> stream5 = Arrays.stream(users);
        stream5.forEach(System.out::println);
    }

1.2Arrays.stream(T[] array) 方法用数组创建

@Test
    public void method2(){
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9);
        //第一种使用list创建stream  stream()
        Stream<Integer> stream = list.stream();
        //输出
        stream.forEach(System.out::println);
        System.out.println("====================");
        //第二种使用list创建stream  parallelStream()  并行流  效率高，无顺序
        Stream<Integer> integerStream = list.parallelStream();
        integerStream.forEach(System.out::println);
    }

1.3使用Stream的静态方法：of()、iterate()、generate()

@Test
    public void method03(){
        //使用Stream的静态方法：of()、iterate()、generate()
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8);
        integerStream.forEach(System.out::println);
        System.out.println("==================");

        //iterate()  第一个参数是一个初始值   第二参数是一个函数式接口，里面的方法是一个参数一个返回值
        //从第一个参数的初始值开始，也就是从0开始，不停歇往stream里添加数据，添加的数据就是接口方法的返回值
        Stream.iterate(0,(x)-> x+1).limit(4).forEach(System.out::println);
        System.out.println("==================");

        //generate()
        Stream.generate(()->{
            return 1;
        }).limit(4).forEach(System.out::println);
    }

二、Stream流中常用的API

@Test
    public void method01(){
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9);
        //foreach  遍历
        list.stream().forEach(System.out::println);
        System.out.println("====================");
        //findFirst  获取第一个
        Optional<Integer> first = list.stream().findFirst();
        System.out.println(first.get());
        System.out.println("====================");
        //findany  获取任意一个
        Optional<Integer> any = list.parallelStream().findAny();
        System.out.println(any.get());
        System.out.println("====================");
        //元素匹配，存在符合条件的元素，则返回true
//        boolean b = list.stream().anyMatch(new Predicate<Integer>() {
//            @Override
//            public boolean test(Integer integer) {
//                return integer > 8;
//            }
//        });
        boolean b = list.stream().anyMatch(i -> i > 8);
        System.out.println(b);
    }

    //过滤
    @Test
    public void method02(){
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9);
        //查找出集合中的偶数
        Stream<Integer> stream = list.stream();
        //过滤查找
        Stream<Integer> integerStream = stream.filter(i -> {
            if (i % 2 == 0) {
                return true;
            }
            return false;
        });
        integerStream.forEach(System.out::println);
        System.out.println("==========================");
        //查找出集合中大于3的数据
        list.stream().filter(i->i>3).forEach(System.out::println);
        System.out.println("==========================");
        //创建一个字符串数组，里面存储多个人名。找出人名长度大于3的。
        String[] names = {"lily","jack","tom","kna"};
        Stream<String> stream1 = Arrays.stream(names);
        stream1.filter(s-> s.length()>3).forEach(System.out::println);

        System.out.println("==========================");
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900,22, "女", "武汉"));
        personList.add(new Person("李磊", 7000,33, "男", "上海"));
        personList.add(new Person("Lucy", 7800,44, "女", "北京"));
        personList.add(new Person("狗哥", 8200,55, "男", "深圳"));
        personList.add(new Person("Lily", 9500,66, "女", "深圳"));
        personList.add(new Person("Jim", 7900,77, "男", "深圳"));
        //查找出薪资大于8000的人员信息
        personList.stream().filter(p->p.getSalary()>8000).forEach(System.out::println);
    }

@Test
    public void method01(){
        //1 . 获取String集合中最长的元素
        List<String> list = Arrays.asList("李磊", "韩梅梅", "Lucy", "Jim");
        Optional<String> max = list.stream().max((s1, s2) -> s1.length() - s2.length());
        System.out.println(max.get());

        //获取String集合中最短的元素
        Optional<String> min = list.stream().min((s1, s2) -> s1.length() - s2.length());
        System.out.println(min.get());


        //2. 获取Integer集合中的最大值
        List<Integer> list2 = Arrays.asList(7, 6, 9, 4, 11, 6);

        //lambda表达式写法
        Optional<Integer> max1 = list2.stream().max((i1, i2) -> i1 - i2);
        Optional<Integer> max2 = list2.stream().max((i1, i2) -> i1.compareTo(i2));

        System.out.println(max1.get());
        //简化写法： 类名::动态方法名
        list2.stream().max(Integer::compareTo);

        //3.count计数
        //查找出大于5的数据的个数
        long count = list2.stream().filter(i -> i > 5).count();
        System.out.println("大于5的个数为:"+count);

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900,22, "女", "武汉"));
        personList.add(new Person("李磊", 7000,33, "男", "上海"));
        personList.add(new Person("Lucy", 7800,44, "女", "北京"));
        personList.add(new Person("狗哥", 8200,55, "男", "深圳"));
        personList.add(new Person("Lily", 9500,66, "女", "深圳"));
        personList.add(new Person("Jim", 7900,77, "男", "深圳"));
        //查找出性别为男的员工中，工资最高的人员信息
        Optional<Person> person = personList.stream().filter(p -> p.getSex().equals("男"))
                .max((p1, p2) -> p1.getSalary() - p2.getSalary());
        System.out.println(person.get());
        //查找出性别为女，并且年龄在40岁以下的，工资最低的人员信息
        Optional<Person> person2 = personList.stream().filter(p ->
                p.getSex().equals("女") && p.getAge() < 40
        ).min((p1, p2) -> p1.getSalary() - p2.getSalary());
        System.out.println(person2.get());
    }

三、Stream流中map方法的应用

@Test
    public void method01(){
        //1. 英文字符串数组的元素全部改为大写。
        String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
        Stream<String> oldStream = Arrays.stream(strArr);
        Stream<Object> newStream = oldStream.map(new Function<String, Object>() {
            @Override
            public Object apply(String s) {
                return s.toUpperCase();
            }
        });
        newStream.forEach(System.out::println);
        System.out.println("=======================");

        //2.将数字集合中的每一个数字加三
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6);
        list.stream().map(i->i+3).forEach(System.out::println);
        System.out.println("=======================");
        //3.将所有员工的工资加三千并进行输出
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900,22, "女", "武汉"));
        personList.add(new Person("李磊", 7000,33, "男", "上海"));
        personList.add(new Person("Lucy", 7800,44, "女", "北京"));
        personList.add(new Person("狗哥", 8200,55, "男", "深圳"));
        personList.add(new Person("Lily", 9500,66, "女", "深圳"));
        personList.add(new Person("Jim", 7900,77, "男", "深圳"));
//        Stream<Person> newPersonStream = personList.stream().map(p -> {
//            p.setSalary(p.getSalary() + 3000);
//            return p;
//        });
//        newPersonStream.forEach(System.out::println);
        Stream<Person> newPersonStream2 = personList.stream().map(p -> {
            Person p2 = new Person(p.getName(), p.getSalary() + 3000, p.getAge(), p.getSex(), p.getArea());
            return p2;
        });
        newPersonStream2.forEach(System.out::println);
        System.out.println(personList);
        System.out.println("=======================");
        //4.将所有员工的工资加三千块，并输出每个员工的工资
        Stream<Integer> integerStream = personList.stream().map(p -> {
            return p.getSalary() + 3000;
        });
        integerStream.forEach(System.out::println);
        System.out.println("=======================");
        //5.所有员工工资减两千，并获得工资总和
        Optional<Integer> reduce = personList.stream().map(p -> p.getSalary() - 2000).reduce((x, y) -> x + y);
        System.out.println(reduce.get());
        System.out.println("=======================");
        //6.将两个字符串分割，放到一个list中去
        List<String> list2 = Arrays.asList("m-k-l-a", "1-3-5-7");
        Stream<String> stringStream = list2.stream().flatMap(s -> {
            String[] split = s.split("-");
            Stream<String> stream = Arrays.stream(split);
            //将单个的流返回，最终它们会合并为一个新的流
            return stream;
        });
        stringStream.forEach(System.out::println);
        System.out.println("=======================");
        //创建一个Integer集合，里面存储一些数字，如果说数字是偶数，则乘以二，是奇数则减一
        //将所有处理后的数据输出
        List<Integer> list1 = new ArrayList<>();
        Collections.addAll(list1,1,2,3,4,5,6,7,8,9);
        list1.stream().map(i->{
            if (i%2==0){
                return i*2;
            }else {
                return i-1;
            }
        }).forEach(System.out::println);
        System.out.println("=======================");
        //找到所有员工工资大于8000的员工，并输出其名字
        personList.stream().filter(p->p.getSalary()>8000).map(p->p.getName());
        personList.stream().filter(p->p.getSalary()>8000).map(Person::getName).forEach(System.out::println);
        System.out.println("=======================");
        //找到性别为男的员工中的工资最低的人，并输出其名字
        //Stream和Optional都可以使用map方法
        Optional<String> o = personList.stream()
                .filter(p -> p.getSex().equals("男"))
                .min((p1, p2) -> p1.getSalary() - p2.getSalary())
                .map(p->p.getName());
        System.out.println(o.get());
    }

//归约
    @Test
    public void method01(){
        //1. 求Integer集合的元素之和、乘积和最大值
        List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
        //求和
        Optional<Integer> reduce = list.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
//                return integer + integer2;
                return Integer.sum(integer,integer2);
            }
        });
        Optional<Integer> reduce1 = list.stream().reduce((i1, i2) -> i1 + i2);
        //第一个参数时初始值
        Integer reduce7 = list.stream().reduce(10, (i1, i2) -> i1 + i2);
        Optional<Integer> reduce2 = list.stream().reduce(Integer::sum);
        System.out.println(reduce.get());
        System.out.println(reduce1.get());
        System.out.println(reduce7);

        //求最大值
        Optional<Integer> reduce3 = list.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer > integer2 ? integer : integer2;
            }
        });
        System.out.println(reduce3.get());
        Optional<Integer> reduce4 = list.stream().reduce((i1, i2) -> i1 > i2 ? i1 : i2);
        System.out.println(reduce4.get());

        //求乘积
        Optional<Integer> reduce5 = list.stream().reduce((i1, i2) -> i1 * i2);
        System.out.println(reduce5.get());

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900,22, "女", "武汉"));
        personList.add(new Person("李磊", 7000,33, "男", "上海"));
        personList.add(new Person("Lucy", 7800,44, "女", "北京"));
        personList.add(new Person("狗哥", 8200,55, "男", "深圳"));
        personList.add(new Person("Lily", 9500,66, "女", "深圳"));
        personList.add(new Person("Jim", 7900,77, "男", "深圳"));
        //找出性别为男的所有员工的工资总和
        Optional<Integer> reduce6 = personList.stream()
                .filter(p -> p.getSex().equals("男"))
                .map(Person::getSalary).reduce((i1, i2) -> i1 + i2);
        System.out.println(reduce6.get());

        //找出员工的最高工资
        Optional<Integer> max = personList.stream()
                .map(Person::getSalary)
                .max((i1, i2) -> i1 - i2);
        System.out.println(max.get());
        Optional<Integer> reduce8 = personList.stream()
                .map(Person::getSalary)
                .reduce((i1, i2) -> i1 > i2 ? i1 : i2);
        System.out.println(reduce8.get());

    }

四、collect收集

/**
 * collect收集
 */
public class StreamTest01 {

    @Test
    public void method01(){
        //将大于5的数据重新生成一个list集合
        List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
        Stream<Integer> integerStream = list.stream().filter(i -> i > 5);
        List<Integer> collect = integerStream.collect(Collectors.toList());
        System.out.println(collect);

        //将大于5的数据重新生成一个set集合
        Set<Integer> collect1 = list.stream().filter(i -> i > 5).collect(Collectors.toSet());
        System.out.println(collect1);

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900, 18,"女", "武汉"));
        personList.add(new Person("李磊", 7000,19, "男", "上海"));
        personList.add(new Person("Lucy", 7800,17, "女", "北京"));
        personList.add(new Person("狗哥", 8200,18, "男", "深圳"));
        personList.add(new Person("Lily", 9500,17, "女", "深圳"));
        personList.add(new Person("Jim", 7900,17, "男", "深圳"));
        //获取工资大于8000的人员，返回一个map
        Map<String, Person> collect2 = personList.stream()
                .filter(p -> p.getSalary() > 8000)
                .collect(Collectors.toMap(Person::getName, p -> p));
        System.out.println(collect2);

        /**
         * 计数：count
         * 平均值：averagingInt、averagingLong、averagingDouble
         * 最值：maxBy、minBy
         * 求和：summingInt、summingLong、summingDouble
         * 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
         */
        //获取工资大于8000的人员的数量
        long count = personList.stream().filter(p -> p.getSalary() > 8000).count();
        Long collect3 = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.counting());
        System.out.println(collect3);

        //获取所有员工的工资的平均值
        Double collect4 = personList.stream().collect(Collectors.averagingInt(Person::getSalary));
        System.out.println(collect4);

        //获取员工工资的最大值
        Optional<Integer> collect5 = personList.stream().map(Person::getSalary).collect(Collectors.maxBy((s1, s2) -> s1 - s2));
        System.out.println(collect5.get());

        //获取员工工资和
        Integer collect6 = personList.stream().collect(Collectors.summingInt(p -> p.getSalary()));
        System.out.println(collect6);

        //统计工资的所有
        IntSummaryStatistics collect7 = personList.stream().collect(Collectors.summarizingInt(Person::getSalary));
        System.out.println(collect7);

        /**
         * 分组(partitioningBy/groupingBy)
         */

        //将员工工资按照是否高于8000来分组
        Map<Boolean, List<Person>> collect8 = personList.stream().collect(Collectors.partitioningBy(p -> p.getSalary() > 8000));
        System.out.println(collect8);

        //按照员工的性别分组
        Map<String, List<Person>> collect9 = personList.stream().collect(Collectors.groupingBy(p -> p.getSex()));
        System.out.println(collect9);

        //按照员工的性别和地区分组
        Map<String, Map<String, List<Person>>> collect10 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println(collect10);

        /**
         * 接合(joining)
         */
        //将所有员工的信息相结合，并且使用,隔开
        String collect11 = personList.stream().map(Person::getName).collect(Collectors.joining("-"));
        System.out.println(collect11);
    }
}

public class StreamTest02 {

    @Test
    public void method01(){
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900, 18,"女", "武汉"));
        personList.add(new Person("李磊", 7000,19, "男", "上海"));
        personList.add(new Person("Lucy", 7800,17, "女", "北京"));
        personList.add(new Person("狗哥", 8200,18, "男", "深圳"));
        personList.add(new Person("Lily", 9500,17, "女", "深圳"));
        personList.add(new Person("Jim", 7900,17, "男", "深圳"));

        //按照年龄排序
        personList.sort((p1,p2)->p1.getAge()-p2.getAge());
        System.out.println(personList);

        List<Person> collect = personList.stream().sorted((p1, p2) -> p1.getAge() - p2.getAge()).skip(1).limit(4).collect(Collectors.toList());
        personList.stream().sorted(Comparator.comparing(Person::getAge).reversed());
        //先按照年龄，再按照工资
        personList.stream().sorted(Comparator.comparing(Person::getAge).thenComparing(Comparator.comparing(Person::getSalary)));

        System.out.println(collect);

        /**
         * 提取，组合
         */
        String[] arr1 = { "a", "b", "c", "d","e" };
        String[] arr2 = { "c","d", "e", "f", "g" };

        //concat  合并
        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(System.out::println);
        System.out.println("====================");
        //distinct 去重
        Stream<String> stream3 = Stream.of(arr1);
        Stream<String> stream4 = Stream.of(arr2);
        Stream<String> distinct = Stream.concat(stream3, stream4).distinct();
        distinct.forEach(System.out::println);
        System.out.println("====================");
        //limite 限制
        Stream<Integer> limit = Stream.iterate(10, i -> i + 1).limit(5);
        limit.forEach(System.out::println);
        System.out.println("====================");
        //skip 跳过
        Stream<Integer> limit1 = Stream.iterate(10, i -> i + 1).skip(1).limit(5);
        limit1.forEach(System.out::println);

    }
}

五、综合练习

public class Test01 {

    public static void main(String[] args) {
        List<User> users = Arrays.asList(
                new User(1, "亚索", "巨神峰", 20, 99, new Date(), Arrays.asList("吹风", "吹笛子", "睡觉")),
                new User(2, "德玛", "德玛西亚", 21, 95, new Date(), Arrays.asList("大保健", "冲锋", "睡觉")),
                new User(3, "光辉", "德玛西亚", 22, 80, new Date(), Arrays.asList("魔法棒", "激光", "睡觉")),
                new User(4, "发条", "黑色玫瑰", 23, 75, new Date(), Arrays.asList("玩球", "上发条")),
                new User(5, "铁男", "黑色玫瑰", 24, 75, new Date(), Arrays.asList("棒子", "小黑屋", "睡觉")),
                new User(6, "提莫", "巨神峰", 25, 70, new Date(), Arrays.asList("种蘑菇", "采蘑菇", "吹笛子")),
                new User(7, "卢锡安", "巨神峰", 26,60, new Date(), Arrays.asList("双枪", "滑步")),
                new User(8, "卡牌大师", "诺克萨斯", 27, 65, new Date(), Arrays.asList("玩牌", "黄牌")),
                new User(9, "雷克顿", "德玛西亚", 28, 60, new Date(), Arrays.asList("飞顿", "睡觉"))
        );
        /**
         * 1.拿到所有用户的名字集合
         * 2.拿到年龄小于25的人的名字集合
         * 3.根据分数倒排序
         * 4.拿到爱好里面有睡觉的 集合
         * 5.拿到来自德玛西亚的用户，根据分数排序，取前两个的名字
         * 6.计算分数总和
         */
        //1.
        users.stream().map(User::getName).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println("================");
        //2.
        users.stream().filter(u->u.getAge()<25).map(User::getName).collect(Collectors.toList());
        //3.
        users.stream().sorted(Comparator.comparing(User::getScore).reversed()).collect(Collectors.toList());
        //4.
        users.stream().filter(u->u.getHobby().contains("睡觉")).collect(Collectors.toList());
        //5.
        users.stream()
                .filter(u->u.getAddr()
                .equals("德玛西亚"))
                .sorted((u1,u2)->u1.getScore()-u2.getScore())
                .limit(2)
                .map(User::getName)
                .collect(Collectors.toList());
        //6.
        System.out.println(users.stream().collect(Collectors.summingInt(User::getScore)));
        users.stream().map(User::getScore).reduce((s1,s2)->s1+s2);
    }
}