1. Toy模板网首页
  2. > Toy博客

Java中的lambda表达式

7月前 作者：tao滔不绝 分类：Toy博客 阅读(37) 违法举报

这篇具有很好参考价值的文章主要介绍了Java中的lambda表达式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

一、背景

二、lambada表达式的基本使用

三、变量捕获

四、lambda在集合中的使用（map和set）

五、优缺点

一、背景

（1）、lambda表达式的定义：

（2）、lambda表达式的语法：

（3）、函数式接口

二、lambada表达式的基本使用

（1）没有使用lambda表达式，简单调用函数式接口展示

（2）上述接口的具体lambda表达式展示

        1、无返回值无参数（NoParameterNoReturn）

        2、无返回值一个参数（OneParameterNoReturn）

        3、无返回值多个参数（MoreParameterNoReturn）

        4、有返回值无参数（NoParameterReturn）

        5、有返回值一个参数（OneParameterReturn）

        6、有返回值多参数（MoreParameterReturn ）

三、变量捕获

（1）、匿名内部类的简单使用

（2）、匿名内部类变量的捕获

（3）、Lambda变量的捕获

四、lambda在集合中的使用（map和set）

（1）、Collection接口

（2）、List接口

（2）、map接口

五、优缺点

优点：

缺点：

都看到这了，给个免费的赞再走吧，谢谢谢谢谢！！！

一、背景

（1）、lambda表达式的定义：

lambda是JavaSE8的一个重要特性，允许用lambda表达式来代替功能接口，lambda表达式和方法一样，有参数，有参数的主体（一个表达式，用花括号括起来）。

（2）、lambda表达式的语法：

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }
 

1、parameters：类似方法体中的形参，这里的参数是函数式接口中方法的参数。

2、->：可以理解为被用于的意思。

3、statements：接口中方法的主体，是函数式接口里的方法实现，这里可以有返回，也可以没有。

（3）、函数式接口

                定义：就是一个接口只有一个抽象方法。

                注意：1、接口中只有一个抽象方法的才是函数式接口。

                           2、@FunctionalInterface 注解 的作用是加了后编译器会按函数式接口的定义来要求该接口，如果该接口有两个抽象方法，则会报错，也可以不加，但是写的时候也要注意，函数式接口只能一个抽象方法。

Java中的lambda表达式,java,1024程序员节

二、lambada表达式的基本使用

        首先，我们先准备好几个函数式接口，代码如下：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

（1）没有使用lambda表达式，简单调用函数式接口展示

lambda表达式也可以理解为简化的匿名内部类，实际上就是创建了一个类，实现了接口，重写了接口里面的方法。

没有使用lambda表达式，我们调用 NoParameterNoReturn函数接口的方法代码如下：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
public class Test {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("重写了NoParameterNoReturn接口的方法");
            }
        };
        noParameterNoReturn.test();
    }
}

创建一个类，实现NoParameterNoReturn接口，重写了函数式接口的方法。

代码执行结果如下：

Java中的lambda表达式,java,1024程序员节

（2）上述接口的具体lambda表达式展示

        1、无返回值无参数（NoParameterNoReturn）

        代码如下：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}

NoParameterNoReturn noParameterNoReturn = () -> { System.out.println("重写了test方法");};
noParameterNoReturn.test();

代码执行结果如下：

Java中的lambda表达式,java,1024程序员节

        2、无返回值一个参数（OneParameterNoReturn）

                 代码如下：

//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}

public static void main(String[] args) {
        //不使用lambda表达式
        OneParameterNoReturn oneParameterNoReturn1 = new OneParameterNoReturn() {
            @Override
            public void test(int a) {
                System.out.println("重写了带有一个参数的test方法，参数为：" + a);
            }
        };
        oneParameterNoReturn1.test(10);
        System.out.println("===================");
      //使用lambda表达式
        OneParameterNoReturn oneParameterNoReturn2 = (int a) -> { System.out.println("重写了带有一个参数的test方法，参数为：" + a);};
        oneParameterNoReturn2.test(20);
    }

代码执行结果如下：

Java中的lambda表达式,java,1024程序员节

        3、无返回值多个参数（MoreParameterNoReturn）

                 代码如下：

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

public static void main(String[] args) {
        //不使用lambda表达式
        MoreParameterNoReturn moreParameterNoReturn1 = new MoreParameterNoReturn() {
            @Override
            public void test(int a, int b) {
                System.out.println("重写了带有2个参数的test方法，参数：" + a + " " + b);
            }
        };
        moreParameterNoReturn1.test(10,20);
        //使用lambda表达式
        MoreParameterNoReturn moreParameterNoReturn2 = (int a, int b) -> {System.out.println("重写了带有2个参数的test方法，参数：" + a + " " + b);};
        moreParameterNoReturn2.test(30,40);
    }

代码执行结果如下：

Java中的lambda表达式,java,1024程序员节

        4、有返回值无参数（NoParameterReturn）

                 代码如下：

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}

public static void main(String[] args) {
        //不使用lambda表达式
        NoParameterReturn noParameterReturn1 = new NoParameterReturn() {
            @Override
            public int test() {
                System.out.println("重写了不带参数的test方法，有返回值");
                return 10;
            }
        };
        System.out.println(noParameterReturn1.test());
        System.out.println("======================");
        //使用lambda表达式
        NoParameterReturn noParameterReturn = () -> {System.out.println("重写了不带参数的test方法，有返回值");return 20;};
        System.out.println(noParameterReturn.test());
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

        5、有返回值一个参数（OneParameterReturn）

                代码如下：

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}

public static void main(String[] args) {
        //不使用lambda表达式
        OneParameterReturn oneParameterReturn1 = new OneParameterReturn() {
            @Override
            public int test(int a) {
                System.out.println("重写了带有一个参数的test方法，参数：" + a);
                return a;
            }
        };
        System.out.println(oneParameterReturn1.test(10));
        //使用lambda表达式
        OneParameterReturn oneParameterReturn2 = (int a) -> {System.out.println("重写了带有一个参数的test方法，参数：" + a);return a;};
        System.out.println(oneParameterReturn2.test(20));
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

        6、有返回值多参数（MoreParameterReturn ）

                 代码如下：

//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

public static void main(String[] args) {
        MoreParameterReturn moreParameterReturn1 = new MoreParameterReturn() {
            @Override
            public int test(int a, int b) {
                System.out.println("重写了带有一个参数的test方法，参数：" + a + " " + b);
                return a + b;
            }
        };
        System.out.println(moreParameterReturn1.test(10, 10));

        MoreParameterReturn moreParameterReturn2 = (int a, int b) -> {System.out.println("重写了带有一个参数的test方法，参数：" + a + " " + b);return a + b;};
        System.out.println(moreParameterReturn2.test(20, 20));
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

三、变量捕获

（1）、匿名内部类的简单使用

class TestDemo {
    public void func(){
        System.out.println("func()");
    }
}
public class Test2 {
    public static void main(String[] args) {
        //匿名内部类的简单使用
        TestDemo testDemo = new TestDemo() {
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
            }
        };
        testDemo.func();
    }
}

代码结果如下：

Java中的lambda表达式,java,1024程序员节

（2）、匿名内部类变量的捕获

class TestDemo {
    public void func(){
        System.out.println("func()");
    }
}

public static void main(String[] args) {
        int a = 100;
        //匿名内部类变量的捕获
        TestDemo testDemo = new TestDemo() {
            public void func() {
                //a = 99;err
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("捕获了a：" + a);
            }
        };
        testDemo.func();
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

（3）、Lambda变量的捕获

@FunctionalInterface
interface NoParameterNoReturn1 {
    void test();
}

public static void main(String[] args) {
        int a = 100;
        NoParameterNoReturn noParameterNoReturn = () -> {
            //a = 99;err
            System.out.println("捕获变量："+a);};
        noParameterNoReturn.test();
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

四、lambda在集合中的使用（map和set）

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。
Java中的lambda表达式,java,1024程序员节

（1）、Collection接口

forEach() 方法演示：
该方法在接口 Iterable 当中，原型如下：

Java中的lambda表达式,java,1024程序员节

该方法表示：对容器中的每个元素执行action指定的动作
 

forEach() 的使用,代码如下：

public static void main(String[] args) {
        //不使用lambda表达式
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("word");
        list1.add("bit");
        list1.add("lambda");
        list1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s + " ");
            }
        });
        System.out.println();
        System.out.println("=============");
        //使用lambda表达式
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("word");
        list2.add("bit");
        list2.add("lambda");

        list2.forEach((String x) -> {System.out.print(x + " ");});
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

（2）、List接口


sort()方法的演示：
sort方法源码：该方法根据c指定的比较规则对容器元素进行排序。

Java中的lambda表达式,java,1024程序员节

sort() 的使用：

public static void main(String[] args) {
        //不使用lambda表达式
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("word");
        list1.add("bit");
        list1.add("lambda");
        list1.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        System.out.println(list1);
        System.out.println("===================");
        //使用lambda表达式
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("word");
        list2.add("bit");
        list2.add("lambda");
        list2.sort((String o1, String o2) -> {return o1.length() - o2.length();});
        System.out.println(list2);
    }

代码结果如下：

Java中的lambda表达式,java,1024程序员节

（2）、map接口

HashMap 的 forEach()
该方法原型如下：
Java中的lambda表达式,java,1024程序员节

Java中的lambda表达式,java,1024程序员节

作用是对Map中的每个映射执行action指定的操作。

forEach() 方法演示：

public static void main(String[] args) {
        //不使用lambda表达式
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1, "hello");
        map1.put(2, "word");
        map1.put(3, "bit");
        map1.put(4, "lambda");
        map1.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.print(integer + "=" + s + " ");
            }
        });
        System.out.println();
        System.out.println("=============");
        //使用lambda表达式
        HashMap<Integer, String> map2 = new HashMap<>();
        map2.put(1, "hello");
        map2.put(2, "word");
        map2.put(3, "bit");
        map2.put(4, "lambda");
        map2.forEach((Integer a, String b) -> {System.out.print(a + "=" + b + " ");});
    }

结果如下：

Java中的lambda表达式,java,1024程序员节

五、优缺点

优点：

        1、代码简洁，开发迅速

        2、方便函数式编程

        3、非常容易进行并行计算

        4、java引入了lambda表达式，改善了集合操作

缺点：

        1、代码可读性差

        2、在非并行计算中，性能未必比传统的for性能高

        3、不容易进行调试文章来源地址https://www.toymoban.com/news/detail-715296.html

都看到这了，给个免费的赞再走吧，谢谢谢谢谢！！！

到了这里，关于Java中的lambda表达式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 进阶JAVA篇- Lambda 表达式与 Lambda 表达式的省略规则

    进阶JAVA篇- Lambda 表达式与 Lambda 表达式的省略规则

    目录         1.0 什么是 Lambda 表达式？         1.1 既然跟匿名内部类相关，先来回顾匿名内部类。          1.2 Lambda 表达式与匿名内部类之间的关系。         1.3 函数式接口         1.4 在具体代码中来操作一下         2.0 Lambda 表达式省略规则          Lambda 表达

    2024年02月08日
    浏览(39)

  • Java Lambda表达式

    1.1 函数式编程思想概括 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作” 面向对象思想强调“必须通过对象的形式来做事情” 函数式思想则尽量忽略面

    2024年02月07日
    浏览(44)

  • Java- Lambda表达式

    目录 一、Lambda简介 二、Lambda使用前提 三、Lambda语法 1.操作符 a.\\\"-\\\"  b.\\\"::\\\" 2.格式  a.无参数 b.有参数 四、Lambda演化过程 五、Lambda实现排序 Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）

    2024年02月03日
    浏览(60)
  • Java Lambda 表达式

    Java Lambda 表达式

    💗wei_shuo的个人主页 💫wei_shuo的学习社区 🌐Hello World ！ Java Lambda 表达式是 Java 8 引入的一种函数式编程特性，它是一种轻量级的匿名函数，允许我们将函数作为方法的参数进行传递。Lambda 表达式可以理解为是一种简洁的方式来表示可传递的代码块，它可以替代传统的匿名内

    2024年02月08日
    浏览(38)
  • Lambda表达式（JAVA）

    Lambda表达式（JAVA）

    注：如果没有学过 匿名内部类 和 接口 不推荐往下看。 (parameters) - expression 或 (parameters) -{ statements; } parameters：表示参数列表； -：可理解为“被用于”的意思； expression：表示一条语句； statements：表示多条语句。 Lambda可以理解为：Lambda就是匿名内部类的简化。 lambda表达式

    2024年02月08日
    浏览(39)
  • java lambda表达式详解

    java lambda表达式详解

    我们知道，在Java中，接口是不能实例化的，但是接口对象可以指向它的实现类对象。如果接口连实现对象都没有呢？那还可以使用匿名类的方式，如下: 复制 但是，使用匿名内部的方式，代码量其实并不是非常简洁，而为了使代码更加的简洁，Java引进了 Lambda 表达式的写法，

    2024年02月03日
    浏览(37)
  • Java学习——lambda表达式

    Java学习——lambda表达式

    什么是Lambda表达式？ 可以将Lambda表达式理解为一个匿名函数； Lambda表达式允许将一个函数作为另外一个函数的参数； 我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码作为实参）,也可以理解为函数式编程， 将一个函数作为参数进行传递 。 为什么要引入Lambda表

    2024年02月04日
    浏览(44)
  • 【Java基础】Java Lambda表达式详解

    【Java基础】Java Lambda表达式详解

    Lambda 表达式，即函数式编程是 JDK8 的一个新特性，也被称为闭包，Lambda表达式允许把函数作为一个方法的参数，即行为参数化，函数作为参数传递进方法中。 Lambda表达式可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大

    2024年02月04日
    浏览(41)

  • 【JAVA】包装类、正则表达式、Arrays类、Lambda表达式

    包装类是8种基本数据类型对应的引用类型 作用：后期的集合和泛型不支持基本类型，只能使用包装类 基本数据类型和其对应的引用数据类型的变量可以互相赋值 基本数据类型 引用数据类型 byte Byte short Short int Integer long Long char Character float Float double Double boolean Boolean 包装类

    2024年02月13日
    浏览(37)

  • Java 8 Lambda表达式详解

    在Java 8中，引入了一种全新的函数编程概念，即Lambda表达式。这是一个重要的进步，它让Java的功能得以大幅扩展，同时还让代码变得更加简洁明了。接下来，我将详细介绍Lambda表达式的相关知识，包括其基本语法、使用场景和特性。 Lambda表达式基本的语法可以分为三个部分

    2024年02月08日
    浏览(68)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包