Lambda表达式

Lambda表达式

初识Lambda

• jdk8开始支持Lambda表达式，用来让程序编写更优雅
• 利用Lambda可以更简洁的实现匿名内部类与函数声明与调用
• 基于Lambda提供stream流式处理极大简化对集合的操作

Lambda表达式语法

（参数列表）->实现语句

• 参数 使用逗号分隔参数 参数类型可以省略 单参数括号可省略
• 实现语句 多行用{}包括 单行可以直接写

public static void main(String[] args) {
        // 约束条件：Lambda表达式只能实现有且只有一个抽象方法的接口，java称为"函数式接口"
        // 常规写法
        MathOperation addition = (Integer a, Integer b) -> {
            System.out.println("加法运算 a：" + a + " b " + b);
            return a + b + 0f;
        };
        float num = addition.operate(2, 3);
        System.out.println(num);

        // 简写形式
        MathOperation substraction = (a, b) ->  a - b + 0f;
        num = substraction.operate(2, 3);
        System.out.println(num);
    }

函数式编程

• 函数式编程是基于函数式接口并使用lambda表达的编程方式
• 函数式编程理念是将代码作为可重用数据代入到程序运行中
• 函数式编程强调“你想做什么”, 而不是“你想怎么做”

什么是函数式接口

• 函数式接口是有且只有一个抽象方法的接口
• Java中拥有大量函数式接口 如Java.Lang.Runnable
• JDK8后提供了一系列新的函数式接口，位于java.util.function

JDK8常用函数式接口

接口	用途
Consumer	对应有一个输入参数无输出的功能代码
Function<T,R>	对应有一个输入参数且需要返回数据的功能代码
Predicate	用于条件判断，固定返回布尔值

Predicate函数式接口

• Predicate是新增的函数式接口，位于java.util.function

• Predicate用于测试传入的数据是否满足判断要求

• Predicate接口需要实现test()方法进行逻辑判断

   public static void main(String[] args) {
          // jdk8以后新增的方法 在java.util.function包下 有个test方法用来测试
          Predicate<Integer> predicate = a -> a > 4;
          System.out.println("测试： " + predicate.test(1));
  
          List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8,9);
          filter(list, n -> n%2 == 0&&n>6);
          filter(list, n -> n%3 == 0);
      }
  
      // 可以利用Predicate这一函数式编程的特性 做封装处理 将处理方式当做参数 传进去
      public static void filter(List<Integer> list, Predicate<Integer> predicate) {
          for (Integer num : list) {
              if ( predicate.test(num)){
                  System.out.println(num);
              }
          }
      }
  

Consumer函数式接口

对应有一个输入参数无输出的功能代码

 public static void output(Consumer consumer) {
       String text = "男人事业应该是第一位,其它的顺其自然";
        consumer.accept(text);
    }

    public static void main(String[] args) {
        output(s-> System.out.println("控制台打印: "+s));
        output(s->{
            System.out.println("向XXX网站发数据包: " + s);
        } );
    }

Function函数式接口

对应有一个输入参数且需要返回数据的功能代码

 public static void main(String[] args) {
        /**
         *  利用Function函数式接口生成定长随机字符串
         */
        Function<Integer, String> randomStringFunction = l -> {
            // 生成随机字符串
            String chars = "abcdefghijklmnopqrstuvwxyz0123456789";
            StringBuffer stringBuffer = new StringBuffer();
            Random random = new Random();
            for (int i = 0; i < l; i++) {
                int index = random.nextInt(chars.length());
                stringBuffer.append(chars.charAt(index));
            }
            return stringBuffer.toString();
        };

        String str = randomStringFunction.apply(16);
        System.out.println("16位随机字符串: " + str);
        str = randomStringFunction.apply(32);
        System.out.println("32位随机字符串: " + str);
    }

函数式编程与面向对象编程比较

	面向对象编程	函数式编程
设计思路	面向对象	面向过程
开发侧重	侧重过程 重分析 重设计	侧重结果 快速实现
可读性	结构复杂 相对较差	更适合人眼阅读 可读性更好
代码量	多	少
并发问题	设计不当 会出现线程安全问题	不会出现线程安全问题
健壮性	好	差
使用场景	中大型大型项目 多人协作工程	小型应用 要求快速实现

Stream介绍

• Stream流式处理 是建立在Lambda基础上的 多数据处理技术
• Stream对集合数据处理进行高度抽象，极大简化代码量
• Stream可对集合进行迭代 去重 筛选 排序 聚合等一些列操作

Stream常用方法

接口	用途
forEach	循环遍历
map	map方法用于通过设置的条件过滤出元素
filter	filter方法用于通过设置的条件过滤出元素
limit	limit方法用于获取指定数量的流
sorted	sorted方法用于对流进行排序
collectors	collectors类实现将流转换成集合和聚合元素

Stream流的五种创建方式

 // 基于数组进行创建 (常用)
    @Test
    public void generator1() {
        String[] arr = {"Lily", "Andy", "Jackson", "Smith"};
        Stream stream = Stream.of(arr);
        stream.forEach(s -> {
            System.out.println(s);
        });
    }

    // 基于集合进行创建 (常用)
    @Test
    public void generator2() {
        List<String> list = new ArrayList<>();
        list.add("Lily");
        list.add("Andy");
        list.add("Jackson");
        list.add("Smith");
        Stream<String> stream = list.stream();
        stream.forEach(s -> {
            System.out.println(s);
        });
    }

    // 利用generate方法创建无限长度流
    @Test
    public void generator3() {
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(10));
        // limit 约束个数 不然会一直循环
        stream.limit(10).forEach(i -> System.out.println(i));
    }

    // 基于迭代器创建
    @Test
    public void generator4() {
        Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
        // limit 约束个数 不然会一直循环
        stream.limit(10).forEach(i -> System.out.println(i));
    }

    // 基于字符序列创建流 (底层需要对字符进行加密的时候)
    @Test
    public void generator5() {
        String str = "abcdefg我的";
        IntStream intStream = str.chars();
        intStream.forEach(c -> System.out.println((char) c));
    }

Stream常用方法

  // 提取集合中所有偶数并求和
    @Test
    public void case1() {
        List<String> list = Arrays.asList("1", "2", "3", "4", "5", "6");
        int sum = list.stream() // 获取stream对象
                .mapToInt(s -> Integer.parseInt(s))// 将字符串转正int
                .filter(s -> s % 2 == 0)// 求偶数
                .sum();// 求和
        System.out.println(sum);
    }

    // 所有名字首字母大写
    @Test
    public void case2() {
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        List newlist = list.stream() // 获取stream对象
                .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))//按照规则对每一个流数据进行转换 没有输出还在在流里面操作
                .collect(Collectors.toList());//  collect 对流数据进行手机 生成新的List/Set
        System.out.println(newlist);
    }

    // 将所有奇数从大到小进行排序 且不许出现重复
    @Test
    public void case3() {
        List<Integer> list = Arrays.asList(1, 17, 13, 12, 13, 20, 18);
        List newList = list.stream().distinct()// 去除重复数据
                .filter(n -> n % 2 == 1)
                .sorted((a, b) -> b - a) // 流数据排序
                .collect(Collectors.toList());
        System.out.println(newList);
    }