首页 > 编程语言 >Java8新特性2_Lambda表达式

Java8新特性2_Lambda表达式

时间：2023-04-17 16:55:23浏览次数：45  
标签：void Java8 static Employee new public 表达式 Lambda

Lambda表达式

为什么要用Lambda表达式

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，将代码像数据一样传递，这样可以写出更简洁、更灵活的代码，作为一个更紧凑的代码风格，使Java语言表达能力得到了提升

实例代码

Lambda表达式最先替代的就是匿名内部类，假设原来我们写一个Comparator比较函数，采用匿名内部类的方式

    /**
     * 原来使用匿名内部类
     */
    public static void test() {
        // 使用匿名内部类，重写Intger的 compare方法
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };

        // 传入比较的方法
        TreeSet<Integer> ts = new TreeSet<>(comparator);
    }

然后在采用Lambda表达式后

    /**
     * 使用Lambda表达式解决匿名内部类需要编写大量模板语言的问题
     */
    public static void test2() {
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);

        // 传入比较的方法
        TreeSet<Integer> ts = new TreeSet<>(comparator);
    }

策略设计模式

假设我们现在有一个需求，就是查找出员工里面年龄超过35的，我们使用策略设计模式

/**
 * 员工类
 *
 * @author: 陌溪
 * @create: 2020-04-05-12:13
 */
public class Employee {
    private String name;
    private int age;
    private double salary;
    
    // set get
}

然后创建一个接口，这里就是判定条件

/**
 * 接口
 * @param <T>
 */
public interface MyPredicte<T> {
    public boolean test(T t);
}

我们实现这个接口

/**
 * 按年龄过滤
 *
 * @author: 陌溪
 * @create: 2020-04-05-12:23
 */
public class FilterEmployeeByAge implements MyPredicte<Employee> {

    @Override
    public boolean test(Employee employee) {
        return employee.getAge() > 35;
    }
}

然后在具体的例子中使用

    /**
     * 获取当前公司员工年龄大于35
     */
    public static void test3() {
        List<Employee> employees = Arrays.asList(
                new Employee("张三", 18, 3333),
                new Employee("李四", 38, 55555),
                new Employee("王五", 50, 6666.66),
                new Employee("赵六", 16, 77777.77),
                new Employee("田七", 8, 8888.88)
        );

        MyPredicte<Employee> mp = new FilterEmployeeByAge();
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : emps) {
            if(mp.test(emp)) {
                emps.add(emp);
            }
        }
    }

当某一天需求变更了，变成需要查找金额大于60000的，那么只需要在编写一个实现类即可

/**
 * 按薪资过滤
 *
 * @author: 陌溪
 * @create: 2020-04-05-12:23
 */
public class FilterEmployeeBySalary implements MyPredicte<Employee> {

    @Override
    public boolean test(Employee employee) {
        return employee.getSalary() > 60000;
    }
}

那么具体使用只需要更改为

    /**
     * 获取当前公司薪资大于60000
     */
    public static void test3() {
        List<Employee> employees = Arrays.asList(
                new Employee("张三", 18, 3333),
                new Employee("李四", 38, 55555),
                new Employee("王五", 50, 6666.66),
                new Employee("赵六", 16, 77777.77),
                new Employee("田七", 8, 8888.88)
        );

        MyPredicte<Employee> mp = new FilterEmployeeBySalary();
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : emps) {
            if(mp.test(emp)) {
                emps.add(emp);
            }
        }
    }

这样一个方法，被称为策略设计模式

匿名内部类

使用上面的策略设计模式，我们会发现一个问题，就是每当我需要增加一个条件的时候，就需要增加一个实现类，如果条件多了的话，那么就会有很多实现类，那么为了优化，我们可以采取匿名内部类的方式

    /**
     * 优化方式，采用匿名内部类的方式
     */
    public static void test5() {
        List<Employee> employees = Arrays.asList(
                new Employee("张三", 18, 3333),
                new Employee("李四", 38, 55555),
                new Employee("王五", 50, 6666.66),
                new Employee("赵六", 16, 77777.77),
                new Employee("田七", 8, 8888.88)
        );

        // 匿名内部类
        filterEmployee(employees, new MyPredicte<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() <= 5000;
            }
        });
    }

直接在内部类中，使用我们的过滤条件

Lambda表达式

    /**
     * 使用Lambda表达式优化
     */
    public static void test6() {
        List<Employee> employees = Arrays.asList(
                new Employee("张三", 18, 3333),
                new Employee("李四", 38, 55555),
                new Employee("王五", 50, 6666.66),
                new Employee("赵六", 16, 77777.77),
                new Employee("田七", 8, 8888.88)
        );

        List<Employee> list = filterEmployee(employees, (e) -> e.getSalary() <= 5000);
        list.forEach(System.out::println);
    }

或者

    /**
     * 不使用策略模式
     */
    public static void test7() {
        List<Employee> employees = Arrays.asList(
                new Employee("张三", 18, 3333),
                new Employee("李四", 38, 55555),
                new Employee("王五", 50, 6666.66),
                new Employee("赵六", 16, 77777.77),
                new Employee("田七", 8, 8888.88)
        );
        employees.stream().filter(e-> e.getSalary() >= 5000).limit(2).forEach(System.out::println);
        
        System.out.println("=========");
        employees.stream().map(Employee::getName).forEach(System.out::println);
    }

学习Lambda

Lambda表达式基础语法：Java8中引入了一个新的操作符 “->” 该操作符称为箭头操作符 或 Lambda操作符

箭头操作符将Lambda表达式拆分为两部分：

  • 左侧：Lambda表达式的参数列表（可以想象成，是上面定义的接口中抽象方法参数的列表）
  • 右侧：Lambda表达式中，所需要执行的功能，即Lambda体（需要对抽象方法实现的功能）

语法格式

1、无参，无返回值

格式：

() -> System.out.println(“hello”);

举例：

    public static void test() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };

        System.out.println("=========");

        Runnable runnable = () -> {
            System.out.println("hello lambda");
        };
    }

JDK1.8以后，调用Lambda外的值，不需要增加final字段，它默认已经添加了final

int n = 10;
Runnable runnable = () -> {
	System.out.println("hello lambda" + n);
};

2、有一个参数，有返回值

格式：

(x) -> System.out.println(x);
或  (一个参数时，小括号可以省略不写)
x -> System.out.println(x);

实例：

public static void test2() {
    Consumer<String> consumer = (x) -> System.out.println(x);
    consumer.accept("我在bilibili");
}

3、有多个参数，一个返回值

    /**
     * 多个参数，有返回值
     */
    public static void test3() {
        Comparator<Integer> comparator = (x, y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);
        };
    }

4、有多个参数，只有一条语句

这个时候，可以省略大括号 和 return


    /**
     * 多个参数，函数体只有一条，并且有返回值时
     */
    public static void test4() {
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
    }

类型推断

Lambda中，表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”。

(Integer x, Integer y) -> Integer.compare(x, y);

但是底层的类型检查还是有的，只是JDK底层帮我们做了类型检查这件事

函数式接口

Lambda表达式需要“函数式接口”的支持

函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，如：

/**
 * 函数式接口 
 */
public interface MyPredicte<T> {
    public boolean test(T t);
}

可以使用注解 @FunctionalInterface 修饰的，则为函数式接口

/**
 * 接口，用于解决重复条件
 * @param <T>
 */
@FunctionalInterface
public interface MyPredicte<T> {
    public boolean test(T t);
}

场景

对一个数进行某种运算

首先创建一个函数式接口

@FunctionalInterface
public interface MyFun {
    public Integer getValue(Integer value);
}

然后在定义一个方法，把方法作为参数传递

    /**
     * 需求：对一个数进行运算
     */
    public static void test5() {
        Integer value = operation(100, (x) -> x*x);
        System.out.println(value);
    }

    public static Integer operation(Integer num, MyFun myFun) {
        return myFun.getValue(num);
    }

训练

  • 调用Collections.sort()方法，通过定制排序比较两个Employee（先比较年龄比，年龄相同比较姓名），使用Lambda表达式
    public static void test() {
        List<Employee> employees = Arrays.asList(
                new Employee("张三", 18, 3333),
                new Employee("李四", 38, 55555),
                new Employee("王五", 50, 6666.66),
                new Employee("赵六", 16, 77777.77),
                new Employee("田七", 8, 8888.88)
        );
        Collections.sort(employees, (e1, e2) -> {
            if(e1.getAge() == e2.getAge()) {
                return e1.getName().compareTo(e2.getName());
            } else {
                return Integer.compare(e1.getAge(), e2.getAge());
            }
        });

        employees.stream().map(Employee::getName).forEach(System.out::println);
    }

Java内置函数接口

Comsumer 消费型接口

格式：Comsumer<T>

传入参数，然后对参数进行操作，没有返回值

    /**
     * 消费型接口
     */
    public static void test() {
        happy(1000, (m) -> System.out.println("消费成功：" + m + "元"));
    }
    public static void happy(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }

Supplier 供给型接口

格式：Supplier<T>

T get();

传入参数，对参数进行操作，然后有返回值

    /**
     * 供给型接口，供给功能如何实现
     */
    public static void test2() {
        List<Integer> list = getNumList(10, () -> {
          Integer a =   (int)(Math.random() * 10);
          return a;
        });

        list.stream().forEach(System.out::println);
    }

    /**
     * 产生指定个数的整数
     * @param n
     * @return
     */
    public static List<Integer> getNumList(Integer n, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(supplier.get());
        }
        return list;
    }

最后输出结果

0
5
9
4
4
3
4
5
0
3

Function 函数型接口

格式：Function<T,R>

R apply(T t);

    /**
     * 函数型接口
     * Function<T, R>
     */
    public static void test3() {
        String str = strHandler("abcdefg", (x) -> {
            return x.toUpperCase().substring(0, 5);
        });
        System.out.println(str);
    }

    /**
     * 需求：用于处理字符串
     */
    public static String strHandler(String str, Function<String, String> function) {
        // 使用apply方法进行处理，怎么处理需要具体实现
        return function.apply(str);
    }

输出结果：

ABCDE

Predicate 断言型接口

格式：Predicate<T>， 用于做一些判断

    /**
     * 断言型接口(把长度大于3的str过滤出来)
     */
    public static void test4() {
        List<String> list = Arrays.asList("abc", "abcd", "df", "cgg", "aaab");
        List<String> result = strPredict(list, (x) -> x.length() > 3);
        result.forEach(item -> {
            System.out.println(item);
        });
    }

    /**
     * 将满足条件的字符串，放入到集合中
     */
    public static List<String> strPredict(List<String> list, Predicate<String> predicate) {
        List<String> result = new ArrayList<>();
        list.forEach(item -> {
            if(predicate.test(item)) {
                result.add(item);
            }
        });
        return result;
    }

扩展

上述的四大核心接口，并不能被适用于一个特殊的应用场景，只能满足大部分的需求

因为他们对于参数的参入有局限性

image-20200406093105110

同时后面针对这样的情况，后面也使用子接口，进行了解决

image-20200406093204147

标签：void,Java8,static,Employee,new,public,表达式,Lambda
From： https://www.cnblogs.com/salixleaf/p/17133957.html

相关文章

  • Java8新特性3_方法引用和构造器
    方法引用与构造器引用方法引用概念若Lambda体中的内容有方法已经实现了，我们可以使用“方法引用”，可以理解为方法引用是Lambda表达式的另外一种表现形式格式对象::实例方法名类::静态方法名类::实例方法名注意Lambda体中，调用方法的参数列表与返回值类型，要与函数式接口......
  • Cron表达式介绍与示例
     1.概念介绍Cron表达式是一个具有时间含义的字符串，字符串以5~6个空格隔开，分为6~7个域，格式为XXXXXXX。其中X是一个域的占位符。最后一个代表年份的域非必须，可省略。单个域有多个取值时，使用半角逗号,隔开取值。每个域可以是确定的取值，也可以是具有逻辑意义的特殊字符......
  • html模板里的表达式不能用小于号
    今天用angular写*ngIf="item.cnt <= 5"这个表达式的时候报错，他将<后面的东西当做html标签来看了，怎么办呢可以用html转义字符来表示小于号<换成下面就可以了*ngIf="item.stockCnt &lt= 5"<<&#60;小于号>>&#62;大于号......
  • Cron表达式
    一、字段释义00/5***?秒分时天(月)月天(周)年份(一般省略)二、符号释义*：表示所有可能的值/：表示数值的增量，简单来说，比如分写上0/5表示从0分开始，每隔5分钟?：仅用在天(月)和天(周)，表示不指定值，当其中一个有值时，另外一个需要设为?每一个字段都......
  • P1449 后缀表达式-模拟栈
    题目描述所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。如：3*(5-2)+7 对应的后缀表达式为：3.5.2.-*7.+@。在该式中，@ 为表达式的结束符号。. 为操作数的结束符号......
  • 运算符、表达式和语句
    运算符、表达式和语句关键字--->while、typedef运算符--->=、-、*、/、%、++、--复合语句、自动类型转换、强制类型转换编写带有参数的函数while循环示例代码:#include<stdio.h>#defineADJUST7.31intmain(void){constdoubleSCALE=0.333;dou......
  • 【c#表达式树】最完善的表达式树Expression.Dynamic的玩法
    【c#表达式树】最完善的表达式树Expression.Dynamic的玩法 引言在我第一次写博客的时候，写的第一篇文章，就是关于表达式树的，链接：https://www.cnblogs.com/1996-Chinese-Chen/p/14987967.html，其中，当时一直没有研究Expression.Dynamic的使用方法(因为网上找不到资料)，就......
  • JavaScript运算符与表达式
    目录一、===二、||三、??与?.???.四、...五、[]{}[]{}一、===严格相等运算符，用作逻辑判断1==1 //返回true1=='1' //返回true，会先将右侧的字符串转为数字，再做比较1==='1' //返回false，类型不等，直接返回falsetypeof查看某个值的类型typeof1 //返回'number'ty......
  • JavaScript 邮箱 验证正则表达式 ，包看懂
    \w就是[0-9a-zA-Z_]\s是[\t\v\n\r\f]\S是[^\t\v\n\r\f]\W是[^0-9a-zA-Z_]\D就是[^0-9]\d就是[0-9].就是[^\n\r\u2028\u2029]。表示几乎任意字符。varreg=/\w{1,30}(\.\w{1,10}){0,2}@\w{1,10}\.\w{1,10}/g\w{1,30}理解为至少有一个字符，最多30个.\w{1,30}理......
  • 第三周——后缀表达式
    题目描述所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。如：3*(5-2)+73*(5-2)+7 对应的后缀表达式为：3.5.2.-*[email protected]*7.+@。在该式中，@ 为表达式的结束符号。.......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99