阶段三/Lambda表达式

最新推荐文章于 2022-10-01 21:00:35 发布

一杯敬朝阳一杯敬月光

最新推荐文章于 2022-10-01 21:00:35 发布

阅读量338

点赞数

分类专栏： Java小白学习之旅文章标签： java 函数式编程 stream

本文链接：https://blog.csdn.net/qq_xuanshuang/article/details/116021627

版权

Java小白学习之旅专栏收录该内容

30 篇文章 0 订阅

订阅专栏

什么是Lambda表达式

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

Lambda语法格式

(参数列表) -> 实现语句

参数列表：使用逗号分隔参数，参数类型可以省略，单参数括号可省略

单行直接写，多行用{}包括，且大括号的最后一句需要明确的写出return语句？

约束条件： Lambda表达式只能实现有且仅有一个抽象方法的接口，java称为"函数式接口"

例子

public interface MathOperation {
    public Float operate(Integer a, Integer b);
}

public interface ProcessOne {
    public Float operate(Integer a);
}

// 1.标准使用方式
// 完成了加法的处理以及实例化
MathOperation addition = (Integer a, Integer b) -> {
    // 因为接口返回类型是Float，a + b返回类型是整型，对不上，所以用+0f隐式转换一下
    // 对不上，会报错，不兼容的类型: lambda 表达式中的返回类型错误，int无法转换为java.lang.Float
    return a + b + 0f;
};
System.out.println(addition.operate(5, 3));

// 2.Lambda允许忽略参数类型
MathOperation substraction = (a, b) ->{
    return a - b + 0f;
};
System.out.println(substraction.operate(5, 3));
// 3.单行实现代码可以省略大括号和return
MathOperation multiplication = (a, b) -> a * b + 0f;
System.out.println(multiplication.operate(5, 3));
// 4.单个参数可以省略小括号
ProcessOne addOne = a -> a + 1.0f;
System.out.println(addOne.operate(3));

函数式编程

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

什么是函数式接口

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

函数式接口Predicte

Predicate是新增的函数式接口，位于java.util.function
Predicate用于测试传入的数据是否满足判断要求
Predicate接口需要实现test()方法进行逻辑判断

直接上例子吧，见多了，自然就熟悉了

/**
 * 理解函数式编程
 * Predicate函数式接口的使用方法
 */
public class PredicateSample {
    public static void main(String[] args){
        Predicate<Integer> predicate = n -> n > 4;
        System.out.println(predicate.test(1));

        List<Integer> list = Arrays.asList(1, 2,3 ,4 , 5, 6, 7, 8, 9, 10);
        /**
         * for(Integer num: list){
         *  if(num % 2 == 1)
         *      System.out.println(num);
         *}*/
        // 函数接口的实现可以作为参数传入到方法中
        filter(list, n -> n % 2 == 1); // 取所有奇数
        filter(list, n -> n % 2 == 0); // 取所有偶数
        filter(list, n -> (n > 5) && (n % 2 == 0)); // 取大于5的所有偶数
    }

    public static void filter(List<Integer> list, Predicate<Integer> predicate){
        for(Integer num: list){
            if(predicate.test(num))
                System.out.print(num + " ");
        }
        System.out.println();
    }
}

JDK8常用函数式接口

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

Consumer接口

public class ConsumerSample {
    public static void main(String[] args){
        output(s -> System.out.println("向控制台打印：" + s));
    }
    public static void output(Consumer<String> consumer){
        String text = "北京欢迎您";
        consumer.accept(text);
    }
}

利用Function接口生成定长随机字符串

public class FunctionSample {
    public static void main(String[] args){
        Function<Integer, String> randomStringFuncyion = l -> {
            String chars = "abcdefghijklmnopqrstuvwxyz0123456789";
            StringBuffer stringBuffer = new StringBuffer();
            Random random = new Random();
            for(int i = 0; i <  l; i++){
                int position = random.nextInt(chars.length());
                stringBuffer.append(chars.charAt(position));
            }
            return stringBuffer.toString();
        };
        String randomString = randomStringFuncyion.apply(9);
        System.out.println(randomString);
        System.out.println(randomStringFuncyion.apply(16));
    }
}

总结

@FunctionalInterface：该注解通知编译器这是函数式接口，进行抽象方法检查

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

Stream流

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

Stream流的五种创建方式

Stream流对象的五种创建方式

基于数组创建
基于集合创建
利用generate方法创建无限长度流
基于迭代器创建流
基于字符序列创建流

public class StreamGenerator {
    // 基于数组创建
    @Test // @Test 注解：表明这是一个测试用例
    public void generator1(){
        String[] arr = {"Lily", "Andy", "Jackson", "Smith"};
        Stream<String> stream = Stream.of(arr);
        stream.forEach(s -> System.out.println("基于数组创建: " + s));
    }
    // 2. 基于集合创建
    @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));
    }
    // 3.利用generate方法创建无限长度流
    @Test
    public void generator3(){
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(1000));
        stream.limit(10).forEach(s -> System.out.println("利用generate方法创建无限长度流: " + s));
    }
    // 4.基于迭代器创建流
    @Test
    public void generator4(){
        Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
        stream.limit(20).forEach(s -> System.out.println("基于迭代器创建流: " + s));
    }
    // 5.基于字符序列创建流
    @Test
    public void generator5(){
        String str = "abcdefg我的";
        IntStream stream = str.chars();
        stream.forEach(c -> System.out.println("基于字符序列创建流: " + (char)c));
    }
}

常用方法

forEach：循环遍历
map：map方法用于映射每个元素到对应的结果
filter：filter方法用于通过设置的条件过滤出元素
limit：limit方法用于获取指定数量的流
sorted：sorted方法用于对流进行排序
Collectors：Collectors类实现将流转换成集合和聚合元素

public class StreamMethod {
    // 提取集合中所有偶数并求和
    @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)) // mapToInt将流中的每一个数据转换为整数
                .filter(n -> n % 2 == 0) // filter对流中的数据进行过滤
                .sum(); // sum对整数流求和
        System.out.println(sum);
    }
    // 所有名字首字母大写
    @Test
    public void case2(){
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        List newList = list.stream()
                .map(s -> s.substring(0,1).toUpperCase() + s.substring(1))
                // collect对流数据进行收集，生成新的List/Set
                .collect(Collectors.toList()); //Collectors.toList将流中的数据转换为list
        System.out.println(newList);
//        .forEach(s -> System.out.println(s));
    }
    // 将所有奇数从大到小排序且不允许重复
    @Test
    public void case3(){
        List<Integer> list = Arrays.asList(1, 60, 38, 21, 51, 60, 51, 73);
        List newList = list.stream()
                .distinct() // 去除重复数据
                .filter(n -> n % 2 ==1)
                .sorted((a, b) -> b - a) // 流数据排序
                .collect(Collectors.toList()); //Collectors.toList将流中的数据转换为list
        System.out.println(newList);
//        .forEach(s -> System.out.println(s));
    }
}

参考：慕课网-Java工程师