函数式编程lambda

Lambda

匿名内部类简写

• 参数类型可以不写， 有参就写参数，无参就空着，
• 只有一个参数时，参数类型和()可以省略，
• 如果实现类只有一行代码，则可以省略{}，同时也要省略;
• 如果实现的代码只有一行并且这行代码为return语句，{}和;可以省略并且return也要省略

        UserDao userDao=new UserDao() {
            @Override
            public int getAge(Integer age) {
                return age;
            }
        };
        
        UserDao userDao1=(age)->{
          return age;  
        };

        UserDao userDao2=age -> {
            return age;
        };
        
        UserDao userDao3=age -> age;

lambda会不会造成内存泄漏

匿名内部类会持有外部类的引用，有造成内存泄漏的风险；

Lambda 表达式，若内部没有引用外部类，则不会持有外部类；若内部引用到了外部类，则会持有外部类。
https://blog.csdn.net/hbdatouerzi/article/details/122534134

Stream流

Lambda表达式forEach 跳出循环

一般的foreach是使用return,但是lanbda中return是无效的，

• 使用anyMatch()方法
  return false，继续执行，return true，结束

      ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);

        numbers.stream().anyMatch(n->{
            //如果n等于2，就结束
            if(n==2){
                System.out.println(n);
                return true;
            }
            System.out.println(n);
            return false;
        });

将List集合某项属性以逗号拼接成字符串

        List<Bd> bds=new ArrayList<Bd>();

        for (int i = 0; i < 5; i++) {
            Bd bd=new Bd();
            bd.setBdname("bdName"+i);
            bd.setBdcode("bdCode"+i);
            bds.add(bd);
        }

        String collect = bds.stream().map(Bd::getBdname).collect(Collectors.joining(";"));
        System.out.println(collect);

根据List中的对象某一属性排序

Comparator.comparing
Comparator.comparingInt
Comparator.comparingLong
Comparator.comparingDouble

//users：list对象，User对象类型，getAge要排序的属性,改变原list
Collections.sort(users, Comparator.comparing(User::getAge));

//筛选年龄大于20，并且按照age从大到小返回一个新的list
List<User> users = list.stream().filter(user -> user.getAge() > 20).sorted(Comparator.comparingInt(User::getAge).reversed()).collect(Collectors.toList());

stream().findFirst()和stream().findAny()

        List<User> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(new User("name"+i,i));
        }
        //stream().findFirst()：获取流中第一个数据
        Optional<User> user = list.stream().findFirst();
        if(user.isPresent()) {
            System.out.println(JSONUtil.toJsonStr(user.get()));
        }
        //stream().findAny()：正常情况下一般会取第一个元素，在并行流的情况下会随机取一个元素
        Optional<User> any = list.parallelStream().findAny();
        if(any.isPresent()) {
            System.out.println(JSONUtil.toJsonStr(any.get()));
        }

常用操作

Stream流都是创建然后中间操作，然后结束操作，才有结果，不然是没有执行结果的

创建流

• 集合创建流

List<Employee> emp= Arrays.asList(new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.55),
            new Employee("王五",58,6666.66),
            new Employee("赵六",16,3333.33),
            new Employee("田七",8,8888.88)
    );
Stream<Employee> stream = emp.stream();

• 数组创建流

        Integer[] arr={1,2,3,4,5,6,7,8};
        Stream<Integer> stream = Arrays.stream(arr);
        Stream<Integer> arr1 = Stream.of(arr);

• map创建流

        HashMap<Object, Object> map = new HashMap<>();
        map.put("zhangsan",10);
        map.put("lisi",20);
        map.put("wangwu",30);

        Stream<Map.Entry<Object, Object>> stream = map.entrySet().stream();

中间操作

• filter()
  条件筛选

        List<User> list = new ArrayList<>();
        //符合条件年龄大于20并且小于30的对象，重新返回为一个List
        List<User> list1 = list.stream().filter(user -> user.getAge() > 20 && user.getAge() < 30).collect(Collectors.toList());

• map()
  map函数的作用就是对管道流中的每一个数据元素进行操作

        List<User> list = new ArrayList<>();
        //获取list中每个User对象的name属性，返回为一个新的list
        List<String> names = list.stream().map(User::getName).collect(Collectors.toList());
        //将字符串list中的值都转为小写，返回一个新的小写List
        List<String> lowerNames = names.stream().map(String::toLowerCase).collect(Collectors.toList());

• distinct
  去重，去除流中的重复元素

        Integer[] arr={1,1,2,2,3,4,5,6,7,8};
        //int数组转为流
        Stream<Integer> stream = Arrays.stream(arr);
		//去重以后转为list
        List<Integer> collect = stream.distinct().collect(Collectors.toList());
        //输出所有元素
        collect.forEach(System.out::println);

• sorted
  对流中元素排序

        Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int数组转为流
        Stream<Integer> stream = Arrays.stream(arr);
		//排序以后转为list
        List<Integer> collect = stream.sorted().collect(Collectors.toList());
        //输出结果
        collect.forEach(System.out::println);

• limit
  设置流的最大长度，超出以后舍弃

    @Test
    public void testLimit(){
        Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int数组转流
        Stream<Integer> stream = Arrays.stream(arr);
        //最大长度3，转为list，超出的不要了
        List<Integer> collect = stream.limit(3).collect(Collectors.toList());
        //输出看结果
        collect.forEach(System.out::println);
    }

• skip
  跳过流的前几个元素，返回剩下的

    @Test
    public void testSkip(){
        Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int数组转流
        Stream<Integer> stream = Arrays.stream(arr);
        //跳过前5个，输出剩下的
        stream.skip(5).forEach(System.out::println);
    }

• flatMap
  map只能把一个对象转换成另一个对象作为流中的元素，
  flatMap可以把一个对象转换成多个对象作为流中的元素

		//emp是个集合，然后emp当前的对象，又执行了一次流处理，只要age>10，就拿到结果，然后这样循环，emp有多少元素，就执行了几次，如果每次有2个符合age>10，那最后的结果collect ，就有20个元素了
        Stream<Employee> employeeStream = emp.stream().flatMap(e -> emp.stream().filter(e1 -> e1.getAge() > 10));
        List<Employee> collect = employeeStream.collect(Collectors.toList());

有点迷糊，感觉就是flatMap中，可以再处理流，再比如

		//emp还是人员对象的集合，但是它有个属性role，是个List形式，然后通过逗号分割，然后再输出
        emp.stream().flatMap(e -> e.getRole().stream()).flatMap(role->Arrays.stream(role.split(","))).forEach(System.out::println);
  

结束操作

• foreach
  对流的元素进行遍历操作

        Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int
        Stream<Integer> stream = Arrays.stream(arr);
        stream.forEach(num-> System.out.println(num));

• count
  获取流的元素个数

    Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int
        Stream<Integer> stream = Arrays.stream(arr);
        System.out.println(stream.count());

• max/min
  获取流的最大或最小值

        Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int
        Stream<Integer> stream = Arrays.stream(arr);
        //System.out.println(stream.max((a,b) -> a-b));
        System.out.println(stream.min((a,b) -> a-b));

• collect
  流转为集合

        Integer[] arr={8,7,9,6,1,3,5,2,4};
        //int
        Stream<Integer> stream = Arrays.stream(arr);
		//转List
        List<Integer> collect = stream.sorted().collect(Collectors.toList());

		//转Map，key为name,value为age
        Map<String, Integer> map = emp.stream().collect(Collectors.toMap(e -> e.getName(), e -> e.getAge()));
        System.out.println(map);    //{李四=38, 张三=18, 王五=58, 赵六=16, 田七=8}

Stream的Debug

链接：Debug调试