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

目录
  • Lambda表达式的进化之路
    • 为什么要使用Lambda表达式
    • Lambda表达式的注意点
    • 下面是Lambda表达式的实现过程
      • 1.最开始使用的是定义外部实现类来完成接口
      • 2.开始使用静态内部类来实现
      • 3.使用局部内部类使用
      • 4.使用匿名内部类实现接口
      • 5..最后使用Lambda表达式实现函数式接口
  • 总结

Lambda表达式的进化之路

为什么要使用Lambda表达式

  • 可以简洁代码,提高代码的可读性
  • 可以避免匿名内部类定义过多导致逻辑紊乱
  • 在原先实现接口抽象方法的时候,需要通过定义一个实现接口的外部类来实现,后面变为定义内部静态类,然后变为用局部内部类实现,再后面变成了定义匿名内部类来实现,最后的最后,为了代码的更加简洁,推出了Lambda表达式,最终实现了用一行代码完成之前多行代码的效果

Lambda表达式的注意点

  • Lambda表达式实际上属于是函数式编程的概念,所以在使用的时候要知道是否属于函数式编程
  • Lambda表达式的实现依赖于接口和父类,所以必须有两者之一才能实现Lam表达式
  • Lambda表达式实现的接口中要求只有一个抽象方法,如果有多个抽象方法就无法使用Lambda表达式来编程
  • Lambda表达式即适用于无参方法,也适用于含参方法
  • Lambda表达式最早在JDK 8中开始出现,所以只有 JDK 8 以后的版本才支持

下面是Lambda表达式的实现过程

1.最开始使用的是定义外部实现类来完成接口

public class tt1 {
    public static void main(String[] args) {
        //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
        lover l1 = new lover();
        l1.love();
    }
}
//定义接口
interface ILove {
    void love();
}
//外部实现类
class lover implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

//输出为:I love you lover ---> 1

2.开始使用静态内部类来实现

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

//输出为:I love you my lover ---> 1
// I love you my lover ---> 2

3.使用局部内部类使用

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
        //局部内部类
        class lover3 implements ILove{
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 3");
            }
        }
        ILove l3 = new lover3();
        l3.love();
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

//输出为:I love you my lover ---> 1
// I love you my lover ---> 2
// I love you my lover ---> 3

4.使用匿名内部类实现接口

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
        //局部内部类
        class lover3 implements ILove{
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 3");
            }
        }
        ILove l3 = new lover3();
        l3.love();
        //使用内部匿名类
        ILove l4 = new ILove() {
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 4");
            }
        };
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

//输出为:I love you my lover ---> 1
// I love you my lover ---> 2
// I love you my lover ---> 3
// I love you my lover ---> 4

5..最后使用Lambda表达式实现函数式接口

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
        //局部内部类
        class lover3 implements ILove{
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 3");
            }
        }
        ILove l3 = new lover3();
        l3.love();
        //使用内部匿名类
        ILove l4 = new ILove() {
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 4");
            }
        };
        l4.love();
        //使用Lambda表达式实现接口
        ILove l5 = () ->{
            System.out.println("I love you my lover ---> 5");
        };
        l5.love();
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

//输出为:
I love you my lover ---> 1
I love you my lover ---> 2
I love you my lover ---> 3
I love you my lover ---> 4
I love you my lover ---> 5

关于Lambda表达式的更加极致的简化(针对有参数的Lambda表达书)

  • 简化数据类型 在Lambda表达式中可以将参数的数据类型省略,只留下一个数据名称。比较特殊的是如果有多个参数,省略的时候应该将所有参数的数据类型都省略,不然就全部不省略,而且需要用括号将参数包含在内。
  • 省略括号 参照上一条,只有一个参数要求的时候才可以省略括号省略花括号
  • 在Lambda表达式中,只有当输出语句或者代码只有一行的时候可以省略花括号。假如有多条执行代码,还是需要用花括号将代码包含在内

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • 一文带你掌握Java8中Lambda表达式 函数式接口及方法构造器数组的引用

    目录 函数式接口概述 函数式接口示例 1.Runnable接口 2.自定义函数式接口 3.作为参数传递 Lambda 表达式 内置函数式接口 Lambda简述 Lambda语法 方法引用 构造器引用 数组引用 函数式接口概述 只包含一个抽象方法的接口,称为函数式接口. 可以通过 Lambda 表达式来创建该接口的对象. 可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口.同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口.

  • 深入理解Java8新特性之Lambda表达式的基本语法和自定义函数式接口

    1.写在前面 目前我们学习Java主要用到的应该就是Java8了,或者说大部分企业当前使用的也是Java8.那么既然Java8的应用如此之广泛,一定有一些亮点所在: Lambda 表达式 函数式接口 方法引用与构造器引用 Stream API 接口中的默认方法与静态方法 新时间日期API 其他新特性 速度更快.代码更少(增加了新的语法 Lambda 表达式).强大的 Stream API.便于并行.最大化减少空指针异常 Optional. 2.为什么要使用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表达式无法抛出异常 1.Demo 例子 2.编译通过 lambda表达式异常应该如何处理 我们看一个例子 Lambda表达式无法抛出异常 1.Demo 例子 错误提示 - Unhandled exception: java.io.IOException; public static void main(String[] args) throws IOException{ Stream.of("a", "b", "c").forE

  • Java中使用Lambda表达式和函数编程示例

    目录 1.简单介绍 2.Lambdas和Scopes 3.Lambdas与局部变量 4.Lambda体与局部变量 5.Lambdas和'This'和'Super'关键字 6.Lambdas和Exceptions 7.预定义的功能接口 1.简单介绍 第一个示例演示变量声明上下文中的lambda.它将lambda()->{System.out.println("running"):}分配给可运行接口类型的变量r. 第二个示例类似,但演示了赋值上下文中的lambda(到先前声明的变量r

  • java Lambda表达式的使用心得

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

  • 吊打Java面试官之Lambda表达式 Stream API

    目录 一.jdk8新特性简介 二.Lambda表达式 简单理解一下Lambda表达式 Lambda表达式的使用 三.函数式接口 1.什么是函数式接口 2.如何理解函数式接口 3.Java内置四大核心函数式接口 四.方法引用与构造器引用 方法引用 构造器引用和数组引用 五.Stream API 1.Stream API的说明 2.为什么要使用Stream API 3.创建Stream的四种方式 4.Stream的中间操作及其测试 5.Stream的终止操作及其测试 六.Optional类的使用 O

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

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

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

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

  • Java8中Lambda表达式使用和Stream API详解

    前言 Java8 的新特性:Lambda表达式.强大的 Stream API.全新时间日期 API.ConcurrentHashMap.MetaSpace.总得来说,Java8 的新特性使 Java 的运行速度更快.代码更少.便于并行.最大化减少空指针异常. 0x00. 前置数据 private List<People> peoples = null; @BeforeEach void before () { peoples = new ArrayList<>(); peoples

  • java中lambda表达式简单用例

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

  • 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表达式的分析与具体用法

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

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

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

  • Java中Lambda表达式用法介绍

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

随机推荐