Java8新特性介绍: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

热门文章

编程学习 ·

javascript 实现所有浏览器异步加载的工具

javascript 实现所有浏览器异步加载的工具 //异步加载 实现 function loadScript(url, callback){ //新建一个script 元素 var script = document.createElement(‘script’); //再往script中添加类型 script.type=“text/javascript”; if(script.readyState){ //每当 rea…
编程学习 ·

POJ练习题之:败方树

问题描述 给定一个整数数组,要求对数组中的元素构建败方树(数组相邻元素两两比较,从第一个元素开始)。之后修改数组中的元素,要求输出初始构建以及修改后得到的败方树的所有内部结点代表的整数(从左到右从上到下输出) 输入 第一行为数组的元素个数n和修改的次数m。 第二行…
编程学习 ·

Paddle_程序员必备的数学知识_转发

程序员——必备数学知识!!!Attention 本博客转发至百度aistudio的<深度学习7日入门-cv疫情检测>,课程非常棒!本人力推! 博客转发地址:https://aistudio.baidu.com/aistudio/projectdetail/604807 课程报名地址:https://aistudio.baidu.com/aistudio/education/group/i…
编程学习 ·

Day 11 武装飞船

《外星人入侵》游戏要实现的是:玩家控制一艘出现在屏幕底部中央的飞船,可以使用箭头左右移动飞船,还可以使用空格来进行射击,游戏开始时候一群外星人出现在天空,他们在屏幕中向下移动,玩家的任务是射杀这些外星人,玩家将所有外星人都消灭干净后,会出现一群新的外星人,…
编程学习 ·

Fedora安装Unity Editor详细步骤

本文固定链接,转载请评论点赞,么么哒 一、起因: 最近一直在用Unity开发Linux版本的应用或者说游戏。Linux是Fedora版本的。Unity官方很早就开始说要专门针对Linux做编辑器了。于是就萌生了要在Fedora上装个Unity的想法。 二、背景: Announcing the Unity Editor for Linux …
编程学习 ·

无线传输技术有哪些?

什么是ZigBee? ZigBee,也称紫蜂,是一种低速短距离传输的无线网上协议,底层是采用IEEE802.15.4标准规范的媒体访问层与物理层。主要特色有低速、低耗电、低成本、支持大量网上节点、支持多种网上拓扑、低复杂度、快速、可靠、安全。 三大特征、八大优势 特征一 ZigBee能源消…
编程学习 ·

一文详解土地增值税

在房地产开发的各个环节,所缴纳的税费不尽相同。其中在商品房销售环节需缴纳的税费比较多,土地增值税是一个主要税种,对企业来说负担比较重,涉及政策也比较复杂。如何确定土地增值税的纳税义务人,明确征税行为和范围;营改增后,土地增值税在应税收入、扣除项目金额、税款预…
编程学习 ·

当我们谈论算法我们在谈论什么:由疫情核酸检测想到的分治算法(Divide-and-Conquer)

原文转载自「刘悦的技术博客」https://v3u.cn/a_id_159 北京的疫情一波未平一波又起,由此看来,战“疫”将是一场旷日持久的战争,绝不能掉以轻心、轻易言胜。病毒随时都会死灰复燃,以生命为代价换来的经验教训值得我们每一个人久久深思。笔者所在的小区也开始组织居民批量进…
编程学习 ·

关于HIVE增量同步的思考

方案一、如果业务库没有删除操作,并且更新时间完整,使用更新时间做增量同步,sqoop只同步更新时间变化的数据,合并到ODS层表 方案二、如果业务库有删除操作,可以先解析数据库操作日志,存到hdfs,T+1同步数据后,对增删改做一次merge操作即可,可能需要代码实现。
编程学习 ·

git使用(二)部署本地项目到github

部署本地项目到github 初始化 打开Git Bash。 cd到项目文件夹。(直接把文件夹拖入到bash内即可) 执行初始化代码 git init项目文件夹会产生一个.git的文件夹 跟github仓库进行连接 格式:git remote add origin url地址(https或ssh)例如:git remote add origin git@github…
编程学习 ·

Centos7中iptables防火墙的设置

防火墙的种类:包过滤防火墙 代理防火墙 状态检测技术通信原理: 一台客户端>iptables>服务器 数据包---》iptables把数据包分类进行处理(各种表rew,mangle,nat,filter表等)-- -》 filter:允许,不允许通过数据包。 nat:进行数据转换的数据包。 mangle:对数据包做…
编程学习 ·

闭包的理解

JS闭包理解及使用 JS中的闭包,其本质就是在函数内部再创建一个函数。 当外部函数执行环境被销毁后,内部函数的作用域链依然保持着对外部函数活动对象的引用,简而言之,闭包就是能够读取其他函数内部变量的函数。 我们可以将闭包理解为:对于外部函数f1,内部函数f2, 当f1终…
编程学习 ·

JMXTrans入门教程

概述 官网 GitHub JMX JMX,即Java Management Extensions,监控Java应用程序系统运行的状态信息,通过分析JMX信息,可用于监控应用程序运行状态、优化程序、排查问题。 JMXTrans JMXTrans是一款开源的JMX指标采集工具,使用简单方便,无需编写代码,只需要配置文件就可以轻松…
编程学习 ·

String类、Arrays类

String类 概念:之前都已经接触到了String的对象,是一个字符串。String类就代表的是字符串 特点 1.双引号引起来的"abc",这种也是String对象,这种对象不是保存到堆中而是方法区的常量池中 2.字符串对象是不可变的对象,只要你观察到字符串的内容变化了,那么肯定是…
编程学习 ·

关于atomic到底安不安全

atomic 实际上相当于一个引用计数器,这个大家很熟悉,如果被标记了atomic,那么被标记了的内存本身就有了一个引用计数器,第一个占用这块内存的线程,会给这个计数器+1,在这个线程操作这块内存期间,其他线程在访问这个内存的时候,如果发现“引用计数器”不为0,则阻塞,实…
编程学习 ·

谷粒商城-elasticsearch

1. elasticsearch基本操作 1.1. 基本概念 Elasticsearch也是基于Lucene的全文检索库,本质也是存储数据,很多概念与MySQL类似的。 对比关系: 索引(indices)----------------------Databases 数据库类型(type)--------------------------Table 数据表文档(Document)--…
编程学习 ·

Codeforces Round #654 (Div. 2) D. Grid-00100(构造)

题目链接 思路:题目要求价值最小,怎么放价值最小?每次放的地方行和列最大值最小值之差为1,那么当行或者列%n==0时就从头开始此时的行列最大值最小值之差依旧是1 #include <cstdio> #include <cstring> #include <algorithm> #include <set> #inclu…