Java 8 stream流 lambda详细操作事例

你的名字 2021-11-09 03:31 271阅读 0赞

### Java 8 stream流： ###

![20190804192402143.png][]

直接上代码：

### 一、新建User类准备数据 ###

import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.math.BigDecimal;
    
    /**
     * @author super zheng
     * @date 2019/8/4 18:06
     * @Description: 这里使用 lombok 
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    public class User {
        // 姓名
        private String name;
        // 年龄
        private Integer age;
        // 性别
        private Integer sex;
        // 所在省市
        private String address;
        // 钱
        private BigDecimal money;
    }

### 二、新建测试类，运用 stream方法 ###

package com.aossci.microservices;
    
    import com.aossci.microservices.lamdba.User;
    import org.apache.commons.lang.StringUtils;
    import org.junit.Test;
    
    import java.math.BigDecimal;
    import java.util.*;
    import java.util.stream.Collectors;
    
    import static java.util.stream.Collectors.counting;
    import static java.util.stream.Collectors.toList;
    
    /**
     * @author super zheng
     * @date 2019/8/4 18:08
     * @Description:
     */
    public class LamdbaTest {
    
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿",new BigDecimal(1)),
                new User("钢铁侠",40,0,"华盛顿",new BigDecimal(1)),
                new User("钢铁侠",40,0,"华盛顿",new BigDecimal(1)),
                new User("蜘蛛侠",20,0,"华盛顿",new BigDecimal(2)),
                new User("赵丽颖",30,1,"湖北武汉市",new BigDecimal(3)),
                new User("詹姆斯",35,0,"洛杉矶",new BigDecimal(4)),
                new User("李世民",60,0,"山西省太原市",new BigDecimal(5)),
                new User("蔡广坤",20,1,"陕西西安市",new BigDecimal(6)),
                new User("葫芦娃的爷爷",70,0,"山西省太原市",new BigDecimal(7))
        );
    
        @Test
        public void testFilter(){
            // 测试过滤条件
            List<User> filterList = list.stream().filter(user -> user.getAge() >= 40)
                    .collect(toList());
            filterList.forEach(System.out::println);
        }
    
        @Test
        public void testDistinct(){
            // 测试去重
            List<User> collect = list.stream().filter(user -> user.getAge() >= 40)
                    .distinct().collect(toList());
            collect.forEach(System.out::println);
        }
    
        @Test
        public void testSort(){
            // 默认为升序
            List<User> collect = list.stream().distinct().sorted(Comparator.comparingInt(User::getAge))
                    .collect(toList());
            collect.forEach(System.out::println);
            System.out.println("--------------------------");
            // 降序排列
            List<User> collect2 = list.stream().distinct().sorted(Comparator.comparingInt(User::getAge)
                    .reversed()).collect(toList());
            collect2.forEach(System.out::println);
        }
    
    
        @Test
        public void testLimit(){
            // 默认升序  limit找出前面几个
            List<User> collect = list.stream().distinct().sorted(Comparator.comparingInt(User::getAge))
                    .limit(1).collect(toList());
            collect.forEach(System.out::println);
    
        }
    
        @Test
        public void testSkip(){
            //  skip的意思是跳过，也就是去除前n个元素
            Set<User> collect = list.stream().distinct().sorted(Comparator.comparingInt(User::getAge))
                    .skip(3).collect(Collectors.toSet());
            collect.forEach(System.out::println);
        }
    
        @Test
        public void testMap(){
            // map(T->R)
            // map是将T类型的数据转为R类型的数据，比如我们想要设置一个新的list，存储用户所有的城市信息。
            // .map(User::getAddress) 相当于 .map(user -> user.getAddress)
            // 此处 map 将 List<User> 转换成 List<String>
            List<String> collect = list.stream().map(User::getAddress).distinct().collect(toList());
            collect.forEach(System.out::println);
        }
    
        @Test
        public void testFlatMap(){
            // flatMap(T -> Stream<R>)
            // 将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流
            List<String> flatList = new ArrayList<>();
            flatList.add("唱,跳");
            flatList.add("rape,篮球,music");
            flatList.add(null);
            //这里原集合中的数据由逗号分割，使用split进行拆分后，得到的是Stream<String[]>，
            // 字符串数组组成的流，要使用flatMap的
            // Arrays::stream
            //将Stream<String[]>转为Stream<String>,
            flatList = flatList.stream().filter(s-> StringUtils.isNotEmpty(s)).map(s -> s.split(",")).flatMap(Arrays::stream).collect(toList());
            flatList.forEach(System.out::println);
        }
    
        @Test
        public void testArrays(){
            List<String> flatList = new ArrayList<>();
            flatList.add("唱,跳");
            flatList.add("rape,篮球,music");
            List<String> strings = new ArrayList<>();
            for (String s : flatList) {
                strings.addAll(Arrays.asList(s.split(",")));
            }
            strings.forEach(System.out::println);
        }
    
        @Test
        public void testAllMatch(){
            //allMatch（T->boolean）
            //
            //检测是否全部满足参数行为，假如这些用户是网吧上网的用户名单，那就需要检查是不是每个人都年满18周岁了。
            boolean b = list.stream().allMatch(user -> user.getAge() >= 18);
            // true
            System.out.println(b);
        }
    
        @Test
        public void testAnyMatch(){
            // anyMatch（T->boolean）
            //
            //检测是否有任意元素满足给定的条件，比如，想知道同学名单里是否有女生。
            boolean b = list.stream().anyMatch(user -> user.getSex()==0);
            System.out.println(b);
        }
    
    
        @Test
        public void testNoneMatch(){
            //noneMatch(T -> boolean)
            //
            //流中是否有元素匹配给定的 T -> boolean 条件。
            boolean isLSJ = list.stream().noneMatch(user -> user.getAddress().contains("山西"));
            System.out.println(isLSJ);
        }
    
        @Test
        public void testFindFirst(){
            Optional<User> fristUser = list.stream().findFirst();
            fristUser.ifPresent(System.out::println);
        }
    
        @Test
        public void testFindAny(){
            //findAny():找到任意一个元素
            Optional<User> any = list.stream().findAny();
            any.ifPresent(System.out::println);
            //这里我们发现findAny返回的也总是第一个元素，
            // 那么为什么还要进行区分呢？因为在并行流 parallelStream() 中找到的确实是任意一个元素。
            Optional<User> any1 = list.parallelStream().findAny();
            any1.ifPresent(System.out::println);
        }
    
        @Test
        public void testCount(){
            long count = list.stream().collect(Collectors.counting());
            long count1 = list.stream().filter(s->s.getAge()>30).count();
            System.out.println(count);
            System.out.println(count1);
        }
    
        @Test
        public void testMax(){
            // 求最大年龄
            Optional<User> max = list.stream().max(Comparator.comparing(User::getAge));
    
            // 求最小年龄
            Optional<User> min = list.stream().min(Comparator.comparing(User::getAge));
    
            max.ifPresent(System.out::println);
            min.ifPresent(System.out::println);
        }
    
    
        @Test
        public void testSum(){
            List<Integer> list2 = new ArrayList<>();
            list2.add(1);
            list2.add(2);
            list2.add(3);
            // 将list中数据全部累加起来
            Integer reduce = list2.stream().reduce(0, Integer::sum);
            System.out.println(reduce);
        }
    
        @Test
        public void testSums(){
            // 求年龄总和
            int totalAges = list.stream().collect(Collectors.summingInt(User::getAge));
    
            int totalAge = list.stream().mapToInt(User::getAge).sum();
            System.out.println(totalAge);
        }
    
        @Test
        public void testSumPuls(){
            List<String> list2 = new ArrayList<>();
            list2.add("1");
            list2.add("2");
            list2.add("3");
            list2.add(null);
            // import org.apache.commons.lang.StringUtils;
            // .filter(StringUtils::isNumeric)  等价于  .filter(s->StringUtils.isNumeric(s))
            IntSummaryStatistics collect = list2.stream().filter(StringUtils::isNumeric)
                    .collect(Collectors.summarizingInt(Integer::valueOf));
            long sum = collect.getSum();
            double average = collect.getAverage();
            long count = collect.getCount();
            int max = collect.getMax();
            int min = collect.getMin();
            System.out.println(sum);
        }
    
    
        @Test
        public void testSumBigDecimal(){
            //BigDecimal来记录金钱，假设想得到BigDecimal的总和
            BigDecimal reduce = list.stream().map(User::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
            System.out.println(reduce.toString());
        }
    
        @Test
        public void testAverage(){
            // 求平均年龄
            Double collect = list.stream().distinct().collect(Collectors.averagingDouble(User::getAge));
            System.out.println(collect);
        }
    
        @Test
        public void testJoins(){
            // 给每个指定的属性添加 “,”
            String collect = list.stream().map(User::getName).distinct().collect(Collectors.joining(","));
            System.out.println(collect);
        }
    
        @Test
        public void testGroupingBy(){
            Map<String, List<User>> cityMap = list.stream()
                    .collect(Collectors.groupingBy(User::getAddress));
            for (Map.Entry<String, List<User>> next : cityMap.entrySet()) {
                System.out.println("--------------------------------");
                System.out.println(next.getKey());
                System.out.println(next.getValue());
                System.out.println("--------------------------------");
            }
        }
    
        @Test
        public void testTwoGroupingBy(){
            Map<String, Map<Integer, List<User>>> collect = list.stream().collect(
                    Collectors.groupingBy(User::getAddress, // 一级分组，按所在地区
                            Collectors.groupingBy(User::getSex)));// 二级分组，按性别
            for (Map.Entry<String, Map<Integer, List<User>>> stringMapEntry : collect.entrySet()) {
                System.out.println("------------------------------");
                System.out.println(stringMapEntry.getKey());
                System.out.println(stringMapEntry.getValue());
                System.out.println("------------------------------");
            }
        }
    
        @Test
        public void testGroupCount(){
            // 统计每个地区的人数
            Map<String, Long> collect = list.stream()
                    .collect(Collectors.groupingBy(User::getAddress, counting()));
            for (Map.Entry<String, Long> stringLongEntry : collect.entrySet()) {
                System.out.println(stringLongEntry.getKey());
                System.out.println(stringLongEntry.getValue());
            }
        }
    
        @Test
        public void testPartitioningBy(){
            //partitioningBy 分区
            //分区与分组的区别在于，
            // 分区是按照 true 和 false 来分的，因此partitioningBy 接受的参数的 lambda 也是 T -> boolean
            Map<Boolean, List<User>> collect = list.stream()
                    .collect(Collectors.partitioningBy(s -> s.getAge() > 30));
            for (Map.Entry<Boolean, List<User>> map : collect.entrySet()) {
                System.out.println(map.getKey());
                System.out.println(map.getValue());
            }
        }
    
        @Test
        public void testRemoveIf(){
            List<User> list2 = new ArrayList<>(this.list);
            // 根据条件删除
            list2.removeIf(user -> user.getAge() <= 40);
            list2.forEach(System.out::println);
        }
    
    
    }

[20190804192402143.png]: /images/20211109/70d34c4e621a4929821c38ebb38155e6.png