Java中Lambda表达式用法介绍

Lambda

lambda是一个匿名函数,我们可以把lambda表达式理解为是一段可以传递的代码。

  • lambda简明的地将代码或方法作为参数传递进去执行。
  • “函数式编程”其核心是把函数作为值。
  • 函数式接口 :只有一个 抽象方法的接口 称之为 函数式接口。函数式接口可以使用@FunctionalInterface进行注解。

lambda表达式拆分为两部分

左侧:lambda 表达式的参数列表

右侧:lambda 表达式中所需要执行的功能,即lambda体

语法格式一:无参数,无返回值

@Test
public void test(){
    // () -> System.out.println("Hello");
    Runnable a = new Runnable(){
     @Override
     public void run(){
        System.out.println("Hello")
    }
    };
    //等同于
    Runnable a1 = () -> System.out.println("Hello");
    a1.run();
}

语法格式二:有一个参数,无返回值(若只有一个参数 小括号可以省略不写)

@Test
public void test(){
    //Consumer被注解@FunctionalInterface的接口(函数式接口) 唯一抽象方法 void accept(T t);
    //左侧参数 -> 右侧执行体
    Consumer<String> con = (x) -> System.out.println(x);
                         // x -> System.out.println(x);
    con.accept("hahah");
}

语法格式三:有两个以上的参数,并且lambda体中有多条语句 (若lambda体中只有一条语句,return 和 大括号都可以省略不写)

@Test
public void test(){
    //Comparator被注解@FunctionalInterface的接口 举例抽象方法 int compare(T o1,T o2);
    Comparator<Integer> com = (x,y) -> {
      System.out.println("hhaha0");
      return (x < y) ? -1 : ((x == y) ? 0 : 1);
    };
    com.compare(1,2);
}

注意:lambda表达式的参数类型可以省略不写,因为jvm编译器可以从上下文推断出数据类型。即“类型推断”如果要在参数里面写数据类型,都要写上。

实例

实例1:

class Employee {
    private String name;
    private int age;
    private double salary;
​
    //省略 get and set and constructor
​
}
interface MyPredicate<T> {
    boolean test(T t);
}
public class Test{
    static List<Employee> list = Arrays.asList(
            new Employee("张三",10,1),
            new Employee("里斯",20,1),
            new Employee("王五",16,1),
            new Employee("二三",30,1)
    );
    public static List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee : list) {
            if(mp.test(employee)){
                emps.add(employee);
            }
        }
        return emps;
 }
    @org.junit.Test
    public void test1(){
        //需要使用自定义的方法
        List<Employee> list2 = filterEmployee(list,(e) -> e.getAge() >= 15);
        list2.stream().map(Employee::getName).forEach(System.out::println);
    }
    @org.junit.Test
    public void test2(){
        //可以使用stream进行list集合的过滤  不使用自定义接口
        List<Employee> list2 = list.stream().filter((e) -> e.getAge() >= 15).collect(Collectors.toList());
        list2.stream().map(Employee::getName).forEach(System.out::println);
    }
}

实例2:

创建一个MyFun接口使用@FunctionalInterface注解,并创建一个抽象方法Integer getValue(Integer num);在Test类对变量进行某种操作。

@FunctionalInterface
interface MyFun{
    Integer getValue(Integer num);
}
public class Test{
    @org.junit.Test
    public void Test(){
        operation(100,num -> ++num);
    }
    /**
    * param1 num : 传入的整形数
    * param2 mf : 实现某种方式对 整形数 进行操作。
    **/
    public Integer operation(Integer num,MyFun mf){
        return mf.getValue(num);
    }
}
class Employee {
    private String name;
    private int age;
    private double salary;
​
    @Override
    public String toString() {
        return "["+this.name+","+this.getAge()+","+this.getSalary()+"]";
    }
    //省略 getter and setter  and constructor
}
​
public class Test {
    List<Employee> list = Arrays.asList(
            new com.bilibili.lambda.test1.Employee("张三",10,1),
            new com.bilibili.lambda.test1.Employee("里斯",20,1),
            new com.bilibili.lambda.test1.Employee("王五",16,1),
            new Employee("二三",30,1)
    );
    @org.junit.Test
    public void test(){
        Collections.sort(list,(e1,e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                //比较年龄大小
                return Integer.compare(e1.getAge(),e2.getAge());
            }
        });
        for (Employee e: list) {
            System.out.println(e);
        }
    }
}

四大核心函数式接口

  • Consumer<T> : 消费性接口 void accept(T t);
  • Supplier<T> : 共给性接口 T get();
  • Function<T,R> : 函数性接口 T代表参数,R代表返回值 R apply(T t);
  • Predicate<T> :断言性接口 boolean test(T t);

class Test{
    @org.junit.Test
    publilc void test(){
        happy(10000,(money)->System.out.println("happy消费"+money+"元"));
    }
    public void happy(double money,Consumer<double> con){
        con.accept(money);
    }
}

lambda方法引用

方法引用:若lambda体中的内同有方法已经实现了,我们可以使用“方法引用”

(可以理解为方法引用时lambda的另一种表现形式)

主要有三种语法格式:

  • 对象::实例方法名
  • 类::静态方法名
  • 类::实例方法名
class Test{
    //对象::实例方法名
    @org.junit.Test
    public void test(){
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("haha");
        Consumer<String> con2 = System.out::println;
        con2.accept("haha");
    }
    //类::静态方法名
    @org.junit.Test
    public void test2(){
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
        Comparator<Integer> com2 = Integer::compare;
        com.compare(1,2);
        com2.compare(1,2);
    }
    //类::实例方法名
    @org.junit.Test(){
        BiPredicate<String,String> bp = (x,y) -> x.equals(y);
        bp.test("a","a");
        BiPredicate<String,String> bp2 = String::equals;
    }
}

lambda构造器引用

格式:

CalssName::new

class Test{
    @org.junit.Test
    public void test(){
        Supplier<String> sup = () -> new String();
        //这里的构造器引用取决于 接口方法的参数 的个数。 此处函数式接口 T get(); 为无参抽象方法所以String在实例化时 也是实例化无参的构造方法  其他类也适用
        Supplier<String> sup2 = String::new;
        String str = sup2.get();
    }
}

到此这篇关于Java中Lambda表达式用法介绍的文章就介绍到这了。希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Java8新特性:lambda表达式总结

    一.Lambda 表达式的基础语法 Lambda 表达式的基础语法:Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符箭头操作符将 Lambda 表达式拆分成两部分: 左侧:Lambda 表达式的参数列表 右侧:Lambda 表达式中所需执行的功能,即 Lambda 体 语法格式一:无参数,无返回值 () -> System.out.println("Hello Lambda!"); 语法格式二:有一个参数,并且无

  • 深入浅出理解Java Lambda表达式之四大核心函数式的用法与范例

    目录 1.四大核心函数式接口 1.1 Consumer<T> : 消费型接口 1.2 Supplier<T> : 供给型接口 1.3 Function<T, R> : 函数型接口 1.4 Predicate<T> : 断言型接口 2.方法引用 2.1 对象 :: 实例方法 2.2 类 :: 静态方法 2.3 类 :: 实例方法 3.构造器引用 4.数组引用 1.四大核心函数式接口 上一篇文章中说到了Lambda表达式中的基本语法,以及我们如何自定义函数式接口

  • 关于Java 中的 Lambda 表达式

    这篇文章我们将讨论关于Java 中的 Lambda 表达式,Lambda 表达式是 Java 涉足函数式编程的过程.它接受参数并将其应用于表达式或代码块.以下是语法的基本示例: (parameter1, parameter2) => expression 或者 (parameter1, parameter2) => {code block} Lambda 表达式非常有限,如果它不是 void,则必须立即返回一个值.他们不能使用诸如 if 或 for 之类的关键字来保持简单性.如果需要更多行代码

  • Java Lambda 表达式源码解析

    Java Lambda 源码分析 问题: Lambda 表达式是什么?JVM 内部究竟是如何实现 Lambda 表达式的?为什么要这样实现? 一.基本概念 1.Lambda 表达式 下面的例子中,() -> System.out.println("1") 就是一个 Lambda 表达式.Java 8 中每一个 Lambda 表达式必须有一个函数式接口与之对应.Lambda 表达式就是函数式接口的一个实现. @Test public void test0() { Runnable

  • Java 进阶使用 Lambda 表达式实现超强的排序功能

    目录 基于Comparator排序 使用 Lambda 表达式替换Comparator匿名内部类 通过静态方法抽取公共的 Lambda 表达式 借助Comparator的comparing方法 多条件排序 在Stream中进行排序 倒序排列 调转排序判断 在Comparator.comparing中定义排序反转 在Stream中定义排序反转 null 值的判断 元素是 null 的笨拙实现 排序条件的字段是 null 文末总结 我们在系统开发过程中,对数据排序是很常见的场景.一般来说,我们可以采

  • java Lambda表达式的使用心得

    目录 Lambda表达式的心得 Lambda表达式法 传统方法 使用Lambda表达式 你首先要知道的 Lambda表达式的技巧 Lambda表达式只能用来简化仅包含一个public方法的接口的创建 双冒号表达形式 Lambda表达式的心得 如题,因为博主也是最近才接触到Lambda表达式的(PS 在这里汗颜一会).我并不会讲解它的原理,诚然任何一件事物如果理解原理的话,使用它必将更加容易.但博主在学习的时候,大多数时候都是学会怎么用,然后在细究原理.就像你骑自行车之前,难道首先还要研究自行车的

  • Java中Lambda表达式的进化之路详解

    目录 Lambda表达式的进化之路 为什么要使用Lambda表达式 Lambda表达式的注意点 下面是Lambda表达式的实现过程 1.最开始使用的是定义外部实现类来完成接口 2.开始使用静态内部类来实现 3.使用局部内部类使用 4.使用匿名内部类实现接口 5..最后使用Lambda表达式实现函数式接口 总结 Lambda表达式的进化之路 为什么要使用Lambda表达式 可以简洁代码,提高代码的可读性 可以避免匿名内部类定义过多导致逻辑紊乱 在原先实现接口抽象方法的时候,需要通过定义一个实现接口

  • Java中Lambda表达式的使用详解

    目录 理解函数式接口以及 Lambda表达式的发展过程 Lambda表达式及语法 一起来看看具体的使用 你需要注意什么 Lambda的实际运用 1.对集合排序 2.遍历集合 3.遍历集合(带条件) 4.代替 Runnable,开启一个线程 理解函数式接口以及 Lambda表达式的发展过程 任何接口,只包含唯一一个抽象方法,就是函数式接口 /** * lambdab表达式的发展 */ public class TestLambda1 { //3.静态内部类 static class Like2 i

  • Java中Lambda表达式用法介绍

    Lambda lambda是一个匿名函数,我们可以把lambda表达式理解为是一段可以传递的代码. lambda简明的地将代码或方法作为参数传递进去执行. "函数式编程"其核心是把函数作为值. 函数式接口 :只有一个 抽象方法的接口 称之为 函数式接口.函数式接口可以使用@FunctionalInterface进行注解. lambda表达式拆分为两部分 左侧:lambda 表达式的参数列表 右侧:lambda 表达式中所需要执行的功能,即lambda体 语法格式一:无参数,无返回值 @

  • java中lambda表达式的分析与具体用法

    Lamda表达式 λ 希腊字母表中排序第十一位字母,英语名称为Lambda 避免匿名内部类定义过多 其实质属于函数式 编程的概念 (params)->expression[表达式] (params)->statement[语句] (params)->{statements} (a-> System.out.print("i like lambda–>"+a)); new Thread (()->System.out.println("多线程

  • java中lambda表达式简单用例

    我对java中lambda表达式的看法是相当纠结的: 一个我这么想:lambda表达式降低了java程序的阅读体验.java程序一直不以表现力出众,正相反使Java流行的一个因素正是它的安全和保守--即使是初学者只要注意些也能写出健壮且容易维护的代码来.lambda表达式对开发人员的要求相对来说高了一层,因此也增加了一些维护难度. 另一个我这么想:作为一个码代码的,有必要学习并接受语言的新特性.如果只是因为它的阅读体验差就放弃它在表现力方面的长处,那么即使是三目表达式也有人觉得理解起来困难呢.语

  • Java中Lambda表达式的使用详细教程

    目录 简介 格式 实例 lambda作为参数 遍历集合 创建线程 排序 简介 说明 本文用示例展示Lambda表达式的用法.同时也会介绍Lambda的相关知识. Lambda表达式介绍 Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能. Lambda表达式是Java SE 8中一个重要的新特性. Lambda与匿名内部类 Lamda表达式指的是应用在SAM(SingleAbstractMethod,含有一个抽象

  • Java中Lambda表达式之Lambda语法与作用域解析

    接上一篇:初探Lambda表达式/Java多核编程[2]并行与组合行为 本节是第二章开篇,前一章已经浅显地将所有新概念点到,书中剩下的部分将对这些概念做一个基础知识的补充与深入探讨实践. 本章将介绍Lambda表达式基础知识. 前言 把上一张书中的结语放到这里作为本章学习内容的开头,以此来概括Lambda表达式的优点: 提升性能.自动的并行化 更棒的API(comparing(...)细粒度的方法将成为标准) 编码风格得到改进.代码简化 反观前面几篇文章中的代码实践,以上三个优点全部得到了验证.

  • Java中Lambda表达式并行与组合行为

    从串行到并行 串行指一个步骤一个步骤地处理,也就是通常情况下,代码一行一行地执行. 如果将我们常用的迭代器式的循环展开的话,就是串行执行了循环体内所定义的操作: sum += arr.get(0); sum += arr.get(1); sum += arr.get(2); //... 在书的一开始,就提到Java需要支持集合的并行计算(而Lambda为这个需求提供了可能). 这些功能将全部被实现于库代码中,对于我们使用者,实现并行的复杂性被大大降低(最低程度上只需要调用相关方法). 另外,关于

  • 浅谈Java中Lambda表达式的相关操作

    为什么要使用Lambda? 可以对一个接口进行非常简洁的实现. Lambda对接口的要求? 接口中定义的抽象方法有且只有一个才可以. 传统实现一个接口需要这样做: 方法一: // 实现接口,同时必须重写接口中抽象方法 class Test implements IntrfacefN { @Override public void getUser(int a, int b) { } } // @FunctionalInterface 注解意思:函数式接口,用来做规范,有这个注解,说明此接口有且只有

  • Java中Lambda表达式基础及使用

    目录 一.举例说明 1.无参无返回 1.1 定义一个接口 1.2接口实现类 1.3 测试类 2.有参无返回代码示例 3.有参有返回 二.简单事项 1.省略模式 2.注意事项 三.Lambda表达式和匿名内部类的区别 1.所需类型不同: 2.使用限制不同: 3.实现原理不同: 标准格式: 三要素:形式参数 箭头 代码块 格式:(形式参数)->{代码块} 形式参数:如果多个参数用逗号隔开,无参留空 ->:英文中划线和大于号组成 代码块:具体要做的事 使用前提: 有一个接口 接口中有且仅有一个抽象方

  • Java中lambda表达式的基本运用

    目录 一.实现接口 二.数字排序 三.字符串排序方法 四.对象排序 总结 一.实现接口 调用一个接口中的方法,传统方法:接口类A: package lombda; /** * @author yeqv * @program A2 * @Classname A * @Date 2022/1/25 20:38 * @Email w16638771062@163.com */ public interface A { int po(int i); } 实现接口: package lombda; /**

随机推荐