Java研学-Lambda表达式

最新推荐文章于 2024-03-25 22:13:13 发布
最新推荐文章于 2024-03-25 22:13:13 发布
阅读量969 收藏 24
点赞数 22
分类专栏： # Java研学 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhlyxx/article/details/134815959
版权

一 Lambda表达式 – 箭头函数

1 含义

  JDK8首次将函数式编程引入到Java代码中;这是一种新型的方法参数传递的方式;直接将获取参数的步骤传递给需要该参数的方法中–Lambda表达式

2 特点

  1 简化代码

  2 多核友好

  3 面向对象思想不足

public class Play {
    public static void main(String[] args) {
        // 实现Runnable的优势在于他避免了单继承的局限性，但需要通过Thread构造器将实现接口的对象传给Thread
        // 多线程输出 匿名内部类实现run方法,通过Thread类调用start开启
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程操作");
            }
        }).start();
        System.out.println("等价于");
        new Thread(()-> System.out.println("新多线程操作")).start();
    }
}

3 例子-自定义水果类,以普通方式与Lambda分别实现

自定义水果类

// 注解需导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Fruit {
    private Long id;        // 编号
    private String name;    // 水果名
    private Integer price;  // 单价
}

普通方法

public class FruitTest {
    // 创建水果集合
    private static List<Fruit> fruits=new ArrayList<>();
    // 水果只需存储一次，进入直接初始化
    static {
        fruits.add(new Fruit(1L,"猕猴桃",6));
        fruits.add(new Fruit(2L,"苹果",5));
        fruits.add(new Fruit(3L,"苹果梨",4));
        fruits.add(new Fruit(4L,"橙子",7));
        fruits.add(new Fruit(5L,"草莓",6));
        fruits.add(new Fruit(6L,"山竹",11));
    }

    public static void main(String[] args) {
        // 查询所有6块钱的水果
        findByPrice();
        // 查询含苹果名字的水果
        findByName();
    }

    private static void findByPrice(){
        List<Fruit> prices=new ArrayList<>();
        for (Fruit f:fruits) {
            if(f.getPrice()==6){
                prices.add(f);
            }
        }
        System.out.println(prices);
    }

    private static void findByName(){
        List<Fruit> names=new ArrayList<>();
        for (Fruit f:fruits) {
            if(f.getName().contains("苹果")){
                names.add(f);
            }
        }
        System.out.println(names);
    }
}

Lambda

// 自定义接口
@FunctionalInterface
public interface IFruit {
    // 接口中定义统一操作规则 根据指定商品信息判断是否满足需求
    boolean test(Fruit f);
}

// 使用
public class FruitTest {
    // 创建水果集合
    private static List<Fruit> fruits=new ArrayList<>();
    // 水果只需存储一次，进入直接初始化
    static {
        fruits.add(new Fruit(1L,"猕猴桃",6));
        fruits.add(new Fruit(2L,"苹果",5));
        fruits.add(new Fruit(3L,"苹果梨",4));
        fruits.add(new Fruit(4L,"橙子",7));
        fruits.add(new Fruit(5L,"草莓",6));
        fruits.add(new Fruit(6L,"山竹",11));
    }
    // 通过匿名内部类改造Lambda实现接口
    public static void main(String[] args) {
        // 查询所有6块钱的水果
        findFruitByI((p)->p.getPrice()==6);
        // 查询含苹果名字的水果
        findFruitByI(p->p.getName().contains("苹果"));

    }

    private static void findFruitByI(IFruit ifr){
        List<Fruit> ff =new ArrayList<>();
        for (Fruit f:fruits) {
            if(ifr.test(f)){
                ff.add(f);
            }
        }
        System.out.println(ff);
    }
}

4 Lambda表达式格式

  Lambda的固定格式核心符号是 ->
  左侧:表示通过Lambda表达式改造方法的参数部分
  右侧:表示通过Lambda表达式进行改造的方法的方法体

5 Lambda表达式改造前提

  必须是接口,并且接口中有且仅有一个抽象方法，为保证接口中只定义一个抽象方法，JDK8提出使用@FunctionaIInterface(函数式接口)

@FunctionalInterface
public interface IFruit {
    // 接口中定义统一操作规则 根据指定商品信息判断是否满足需求
    boolean test(Fruit f);
}

6 Lambda表达式特点演示

public class FruitTest {
	......
    public static void main(String[] args) {
        // ① 没有特殊要求改造方法的参数类型可以省
        List<String> list= Arrays.asList("大黄","大白","小黑");
        // foreach类似增强for
        list.forEach(s-> System.out.println(s));
        // ② 改造方法仅有一个参数时()可以省,没有参数或有多个参数时()不能省
        new Thread(()-> System.out.println("多线程启动")).start();
        // 实例化时通过代码块为map赋值
        Map<String,String> map=new HashMap<String,String>(){
            {
                this.put("大黄","15kg");
                this.put("大白","12kg");
            }
        };
        // ③ 改造方法仅有一条代码{}与;都可以省去,若有多条代码则不能省去,一般改造方法只有一条代码
        map.forEach((k,v)->{
            System.out.println(k);
            System.out.println(v);
        });
        // ④ 改造方法仅一条代码，且为return语句时,return关键字可省去
        findFruitByI(new IFruit() {
            @Override 
            public boolean test(Fruit f) {
                return f.getPrice()==6;
            }
        });
        findFruitByI(p->p.getPrice()==6);
    }
    private static void findFruitByI(IFruit ifr){
        List<Fruit> ff =new ArrayList<>();
        for (Fruit f:fruits) {
            if(ifr.test(f)){
                ff.add(f);
            }
        }
        System.out.println(ff);
    }
}

7 常见函数式接口

函数式接口参数类型返回类型说明
Consumer< T>消费型接口Tvoid对类型为T的对象进行操作，方法：void accept(T t)
Supplier< T>供给型接口无T返回类型为T的对象 方法:T get();(可做工厂)
Function< T，R>函数型接口TR对类型为T的对象进行操作，并且返回结果是R类型(任意数据类型)，方法：R apply(T t);
Predicate< T>断言型接口Tboolean判断类型为T的对象是否满足条件，返回值固定为布尔类型，方法 boolean test(T t)
public class FunctionPlay {
    // 创建水果集合
    private static List<Fruit> fruits = new ArrayList<>();

    // 水果只需存储一次，进入直接初始化
    static {
        fruits.add(new Fruit(1L, "猕猴桃", 6));
        fruits.add(new Fruit(2L, "苹果", 5));
        fruits.add(new Fruit(3L, "苹果梨", 4));
        fruits.add(new Fruit(4L, "橙子", 7));
        fruits.add(new Fruit(5L, "草莓", 6));
        fruits.add(new Fruit(6L, "山竹", 11));
    }

    public static void main(String[] args) {
        buy(36, new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println("买了"+integer+"元的水果");
            }
        });
        buy(456,(consumer)-> System.out.println("买了"+consumer+"元的水果"));

        int it=getRealLength("playthis", new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        });
        System.out.println(it);
        System.out.println(getRealLength("playthis",s -> s.length()));

        System.out.println(getCode(6, new Supplier<Integer>() {
            @Override
            public Integer get() {
                return (int)(Math.random()*10);
            }
        }));
        System.out.println(getCode(8,()->(int)(Math.random()*10)));

        isOk(new Predicate<Fruit>() {
            @Override
            public boolean test(Fruit fruit) {
                return fruit.getPrice()>8;
            }
        });
    }

    // 购买消费金额
    public static void buy(int moeny,Consumer<Integer> consumer){
        // 接口对象consumer调用方法accept传递参数moeny
        consumer.accept(moeny);
    }
    // 获取长度(String真实长度)
    public static int getRealLength(String let, Function<String,Integer> fun){
        return fun.apply(let);
    }
    // 返回指定位数随机码
    public static String getCode(int num, Supplier<Integer> sup){
        // 创建StringBuffered
        StringBuffer sb=new StringBuffer();
        for (int i = 0; i < num; i++) {
            sb.append(sup.get());
        }
        return sb.toString();
    }
    // 判断水果是否超过8元
    public static void isOk(Predicate<Fruit> fp){
        for (Fruit f:fruits) {
            if(fp.test(f)){
                System.out.println(f.toString());
            }
        }
    }
}

8 方法引用

① 普通调用方法的方式

  对象.方法名([参数])

  类名.方法([参数])–必须被static修饰

② 方法引用

  进行Lambda表达式改造后,传递的操作已定义完毕(Java核心类库提供或者是其他程序员定义好的方法),可使用方法引用的方式调用

③ 方法引用的前提

  引用的方法必须是定义好的，必须是Lambda表达式改后的方法

④ 格式-- ::(引用运算符，两个引号)

::左侧 – 通过什么方式引用的即 对象名或类名

::右侧 – 调用方法的名字(方法引用只能引用无参方法，故不能写())

public class PlayMethod {
    public static void main(String[] args) {
        // 对象::方法名
        fun1();
        // 类名::静态方法
        fun2();
        // 类名::方法
        fun3();
        // 类名::new
        fun4();
    }
    // 方法引用有局限性，调用定义好的方法不能灵活应用
    // list.forEach(p-> System.out.println(p));
    private static void fun1(){
        List<String> list= Arrays.asList("大黄","大白","小黑");
        list.forEach(System.out::print);
    }
    // ()->Math.random()
    private static void fun2(){
        Supplier sup=Math::random;
        // get方法获取值
        System.out.println(sup.get());
    }
    // s->s.length()
    private static void fun3(){
        Function<String,Integer> fun=String::length;
        System.out.println(fun.apply("8537矿泉水"));
    }
    // 类名::new 构造器引用
    private static void fun4(){
        /*Supplier<String> sup=new Supplier<String>() {
            @Override
            public String get() {
                return new String();
            }
        };*/
        // ()->new String();
        Supplier<String> sup=String::new;
        System.out.println(sup.get());
    }
}

9 延迟执行

又称延迟加载或懒加载

public class PlayMethod {
    public static void main(String[] args) {
        String name="大黄";
        String is="是";
        String color="黄色的";
        // 拼接 无论是否满足条件此刻都已经完成拼接存放在工具中了(性能浪费)，满足条件才提供结果
        addString("ok",name+is+color);
    }
    private static void addString(String info, String s) {
        if("ok".equals(info)){
            System.out.println(s);
        }
    }
}

使用供给型接口实现延迟加载

public class PlayMethod {
    public static void main(String[] args) {
        String name="大黄";
        String is="是";
        String color="黄色的";
        // 拼接
        /*addString("no", new Supplier<String>() {
            @Override
            public String get() {
                return name+is+color;
            }
        });*/
        addString("ok",()->name+is+color);
    }
    private static void addString(String info, Supplier<String> sup) {
        if("ok".equals(info)){
        // 判断通过才拼接字符串
            System.out.println(sup.get());
        }
    }
}

10 接口的多继承

① 接口能够定义的类成员

  成员常量:public static final 数据类型 常量名=值;

  抽象方法: 返回 方法名([参数]);

  JDK8后,在接口中可定义default和static方法,能够具有方法体

② 代码演示
定义接口A，包含抽象方法fun1()的default方法fun2(),以及static方法fun3();

public interface A {
    void fun1();
    default void fun2(){
        System.out.println("Afun2");
    }
    static void fun3(){
        System.out.println("Afun3");
    }
}

定义接口B，包含default方法fun2(),以及static方法fun3();

C类分别实现AB两个接口

public class C implements A,B{
    @Override
    public void fun1() {

    }
    // 一个类实现多个接口时，若接口中default方法同名
    // 需重写default方法确认调用哪个default方法
    @Override
    public void fun2() {
        B.super.fun2();
    }
}
泰勒疯狂展开
关注
  • 22
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java8--Lambda表达式
qq_48019875的博客
01-20 855
目录一、Java 8 Lambda表达式1、出现的背景2、Lambda表达式简介 一、Java 8 Lambda表达式 1、出现的背景 2、Lambda表达式简介
lambda表达式中的箭头函数
lihuihui01的博客
07-29 1331
语法结构 java中lambda表达式的语法结构：(params) -> expression。 由三部分构成: 第一部分是括号以及括号内部的形式参数 第二部分是"->"箭头符号 第三部分是expression方法体，方法体可以是代码块也可以是执行表达式。 //1. lambda表达式的完整形态：有输入参数，有返回值，有代码块。 (int a, int b) -> { int c = a + b; return c; } //2. lambda表达式在某些情况也可以省略一部
JavaScript之Lambda表达式（箭头函数）
最新发布
m0_73140589的博客
03-25 499
是在es6 中添加的一种规范箭头函数相当于匿名函数， 简化了函数的定义。语言的发展都是倾向于简洁 对人友好，能减轻工作量的。为什么要叫箭头函数，因为函数可以用箭头语法（”=>”）定义。ps:不同的语言，表现可能不一样，如Java是用 ->如果要返回一个对象，就要注意，如果是单表达式，这么写的话会报错。
JavaScript 箭头函数（Lambda表达式）
weixin_30307921的博客
09-10 292
Lambda表达式(箭头函数)用于表示一个函数，所以它和函数一样，也拥有参数、返回值、函数体，但它没有函数名，所以Lambda表达式相当于一个匿名函数。 使用方法： ()=>{} 小括号里放参数，大括号里放函数体 箭头函数做回调参数 [5, 8, 9].map(item => item + 1);// -> [6, 9, 10] 当箭头函数有一个参数时，参数两边的括号...
在js中，lambda表达式在计算机科学中表示匿名函数，理解为就是es6中的箭头函数——lambda表达式基本用法 & 箭头函数特点 & es6删除一个对象的属性，不改变原始对象
weixin_44867717的博客
09-03 1078
js
箭头函数 lambda表达式-(java8新特性)
qq_49074573的博客
12-04 2319
箭头函数lambda表达式
java8-lambda表达式的基础使用.pdf
07-05
Java 8 中 Lambda 表达式的基础使用 Java 8 中的 Lambda 表达式是 Java 8 中最流行最常用的功能特性之一。它将函数式编程概念引入 Java，函数式编程的好处在于可以帮助我们节省大量的代码，非常方便易用，能够大...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
668.666.JAVA基础教程_动态代理与Java8新特性-Lambda表达式使用举例(668).rar
11-09
本教程重点探讨了两个关键的Java技术：动态代理和Java 8的新特性，特别是Lambda表达式的应用。 首先，让我们来理解动态代理。在Java中，动态代理允许我们在运行时创建一个实现了特定接口的代理类。这种技术常用于...
670.668.JAVA基础教程_动态代理与Java8新特性-Lambda表达式语法的使用(670).rar
11-09
本教程重点探讨了两个关键的Java技术：动态代理和Java 8的新特性，特别是Lambda表达式的使用。 首先，让我们深入理解动态代理。在Java中，动态代理允许我们在运行时创建一个实现了一组特定接口的代理类。这种代理类...
JAVA面向对象之箭头函数
Lyajpunov的博客
01-11 5947
箭头函数 如果一个接口只有一个抽象方法，那么这个接口也称之为函数式接口。可以使用@FunctionalInterface注解标识。 @FunctionalInterface public interface Function { int plus(int i,int j); } 当我们使用函数式接口去构造内部类时，我们很简单的表示： public class Client { public static void test(Function function){ Syste
java有箭头函数吗_什么时候不使用箭头函数
weixin_29515317的博客
02-25 222
原标题：什么时候不使用箭头函数原文：http://t.cn/R1iSsk6译者：前端小智为了保证的可读性，本文采用意译而非直译。这些年来，ES6 将 JS 的可用性提升到一个新的水平时: 箭头函数、类等等,这些都很棒。箭头函数是最有价值的新功能之一，有很多好文章描述了它的上下文透明性和简短的语法。但每个事务都有两面。通常，新特性会带来一些混乱，其中之一就是箭头函数被误导了。本文将介绍一些场景，在这...
java 箭头函数_箭头函数丶Java教程网-IT开发者们的技术天堂
weixin_32589387的博客
02-13 3033
基本用法在ES6中允许使用 => 来定义函数，如下：var f = a => a;console.log(f(1)); //1就等同于var f = function(a){return a;}console.log(f(1)); //1从上面可以看出，在箭头左侧的是代表参数，若参数只有一个，()可以省略，箭头右侧的表示函数代码块，若代码块里面是个返回值，则{}可以省略不写1.无参数情...
Java1.8新特性
weixin_38862073的博客
06-08 1141
新特性 目录一、Lambda表达式二、函数式接口 一、Lambda表达式 * * Lambda表达式 * 是一种没有名字的函数，也可称为闭包，是Java8的新特性 * 本质上是一段匿名内部类，也可以是一段可传递的代码。也称箭头函数 * 特点： * 允许把函数作为一个方法的参数（函数作为参数传递到方法中） * 使用Lambda表达式可以让代码变得更加简洁 * 应用场景： * 列表迭代、Map映射、Reduce聚合、想替代一个不想命名的函数或类，该函数或
JavaScript的箭头函数（lambda表达式）
m566666的博客
11-22 2903
JavaScript的箭头函数相当于其他语言的lambda表达式，是普通函数简化的写法，箭头函数的格式如下： （参数1，参数2，参数3...）=>{statements} lambda表达式就是匿名函数 闭包：就是能够访问局部变量的局部函数。 map：对原数组里的每个元素按照map（function（）{}）里的函数逻辑进行处理后，有返回值，形成新数组。 ForEach:对原数组里每个元素按照ForEach(function(){})里的函数进行处理，没有返回值 看如下代码时如何实现箭
javaES6箭头函数的全新特性
郑帅的博客
11-04 2191
导读 胖箭头函数（Fat arrow functions），又称箭头函数，是一个来自ECMAScript 2015（又称ES6）的全新特性。有传闻说，箭头函数的语法“=>”，是受到了CoffeeScript 的影响，并且它与CoffeeScript中的“=>”语法一样，共享this上下文。 箭头函数的产生，主要由两个目的：更简洁的语法和与父作用域共享关键字“this”。接下来，
Java8之Lambda 表达式(箭头函数)
John的博客
04-14 3261
函数式编程思想 在数学中 函数就是有输入量和输出量的一套计算方案 也就是“拿什么东西做什么事情” 相对而言 面向对象过分强调必须通过对象的形式来做事情 而函数式思想则尽量忽略面向对象的复杂语法——强调做什么 而不是以什么形式做 面向对象的思想： 做一件事情 找一个能解决这个事情的对象 调用对象的方法 完成事情 函数式编程思想： 只要能获取到结果 谁去做的 怎么做的都不重要,重视的是结果 不重视过程 可能不太好理解 我们举个简单的栗子： 代码冗余 public static void main(Stri
Java 8 Stream与Lambda表达式深度解析
"Java 8 引入了Stream API和Lambda表达式，这两个特性极大地改变了Java程序员处理集合数据的方式，提供了更加简洁、高效的代码编写方式。以下是对这两个新特性的详细解析。 ## 1. Lambda表达式 Lambda表达式是Java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

泰勒疯狂展开

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值