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

目录
  • 简介
  • 格式
  • 实例
    • lambda作为参数
    • 遍历集合
    • 创建线程
    • 排序

简介

说明

本文用示例展示Lambda表达式的用法。同时也会介绍Lambda的相关知识。

Lambda表达式介绍

  • Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。
  • Lambda表达式是Java SE 8中一个重要的新特性。

Lambda与匿名内部类

Lamda表达式指的是应用在SAM(SingleAbstractMethod,含有一个抽象方法的接口)环境下的一种简化定义形式。

Lambda比匿名内部类的优点

简洁(详见下边“函数式接口”)

Lamda相对于匿名内部类的缺点

  • Lamda对应的接口只能有一个方法。
  • 匿名内部类对应的接口可以有多个方法

对接口的要求

1.Lambda 规定接口中只能有一个需要被实现的方法(即抽象方法)。

在一个接口中,后边几个可同时存在:一个抽象方法(只能有一个)、多个default方法、多个static方法。

// jdk 8 中有另一个新特性:default, 被 default 修饰的方法会有默认实现,不是必须被实现的方法,所以不影响 Lambda 表达式的使用。

2.@FunctionalInterface:用来修饰函数式接口。

@FunctionalInterface写不写都可以。此注解主要用于编译级错误检查:当接口不符合函数式接口定义的时候,编译器会报错。

正确例子,没有报错:

@FunctionalInterface
public interface HelloWorldService {
    void sayHello(String msg);
}

错误例子,报错:

接口中包含了两个抽象方法,违反了函数式接口的定义,提示在接口中找到多个非重写的抽象方法。

注意: 加不加 @FunctionalInterface对于接口是不是函数式接口没有影响,该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。

变量和作用域

  • Lambda 表达式只能引用标记了 final 的外层局部变量。即不能在 lambda 内部修改定义在域外的局部变量,否则编译报错
  • Lambda 表达式的局部变量可以不用声明为 final,但是必须不可被后面的代码修改(即隐性的具有 final 的语义)
  • Lambda 表达式中不允许声明一个与局部变量同名的参数或者局部变量。

格式

lambda表达式的重要特征

  • 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
  • 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
  • 可选的大括号:若主体包含了一个语句,就不需要使用大括号。例: () -> Sysout.out.println("Test");
  • 可选的返回关键字:若主体只有一个表达式返回值则编译器会自动返回值,大括号需指定明表达式返回了一个数值。

Lambda 表达式的简单例子

1. 不需要参数,返回值为 5

() -> 5

2. 接收一个参数(数字类型),返回其2倍的值

x -> 2 * x

3. 接受2个参数(数字),并返回他们的差值

(x, y) -> x – y

4. 接收2个int型整数,返回他们的和

(int x, int y) -> x + y

5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)

(String s) -> System.out.print(s)

语法格式

格式:

(parameters) -> statement   或(parameters) ->{ statements; }

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

右侧:Lambda 表达式中所需要执行的功能 (Lambda体)

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

() -> Sysout.out.println("Test");

语法格式二:有一个参数,并且无返回值

(X)-> Sysout.out.println(x);

语法格式三:如果有一个参数括号可以不写

X-> Sysout.out.println(x);

语法格式四:有两个以上的参数,有返回值,并且Lambda体中有多条语句,语法体中需要用{}

    Comparator<Integer> comparator = (o1, o2) -> {
        System.out.println("Test");
        return Integer.compare(o1, o2);
    };

语法格式五:Lambda体中只用一条语句,return和{}可以省略不写

Comparator comparator = (o1, o2)->Integer.compare(o1, o2);

语法格式六:表达式的参数列表的数据类型可以省略不写,JVM编译器通过上下文推断出数据类型

(x ,y ) ->Integer.compare(x ,y)

实例

无参数无返回值

package org.example.a;

@FunctionalInterface
interface Interface {
    void run();
}

public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class: ");
            }
        };

        Interface params1 = () -> System.out.println("Lambda: ");

        params.run();
        params1.run();
    }
}

执行结果

Anonymous Internal Class: 
Lambda:

有参数无返回值

package org.example.a;

@FunctionalInterface
interface Interface {
    void run(String s);
}

public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
            }
        };

        Interface params1 = (s) -> System.out.println("Lambda: " + s);

        params.run("hello");
        params1.run("hi");
    }
}

执行结果

Anonymous Internal Class: hello
Lambda: hi

有参数有返回值

package org.example.a;

@FunctionalInterface
interface Interface {
    String run(String s);
}

public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public String run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
                return "abc";
            }
        };

        Interface params1 = (s) -> {
            System.out.println("Lambda: " + s);
            return "def";
        };

        System.out.println(params.run("hello"));
        System.out.println(params1.run("hi"));
    }
}

执行结果

Anonymous Internal Class: hello
abc
Lambda: hi
def

lambda作为参数

传递一个函数

package org.example.a;

interface IRun {
    String welcome(String string);
}

class Util {
    public static long executionTime1(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时,防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    public long executionTime2(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时,防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    public static String hello(String string){
        String tmp;
        tmp = "hello: " + string;
        return tmp;
    }

    public String hi(String string){
        String tmp;
        tmp = "hi: " + string;
        return tmp;
    }
}

public class Demo {
    public static void main(String[] args) {
        long time1 = Util.executionTime1(Util::hello, "Tony");
        long time2 = new Util().executionTime2(new Util()::hi, "Pepper");
        System.out.println("time1: " + time1 + "ms");
        System.out.println("time2: " + time2 + "ms");
    }
}

执行结果

hello: Tony
hi: Pepper
time1: 11ms
time2: 11ms

直接传递lambda函数 

package org.example.a;

interface IRun {
    String welcome(String string);
}

class Util {
    public static long executionTime(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时,防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
}

public class Demo {
    public static void main(String[] args) {
        long time = Util.executionTime((string -> {
                    String tmp;
                    tmp = "hello: " + string;
                    return tmp;
                })
                , "Tony");
        System.out.println("time: " + time + "ms");
    }
}

执行结果

hello: Tony
time: 11ms

遍历集合

package org.example.a;

import java.util.ArrayList;
import java.util.List;

public class Demo{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");

        //以前的循环方式
        for (String string : list) {
            System.out.println(string);
        }

        //使用lambda表达式输出list中的每个值
        list.forEach(c->{
            System.out.println(c);
        });

        // 在 Java 8 中使用双冒号操作符(double colon operator)。也属于lamda表达式
        list.forEach(System.out::println);
    }
}

执行结果

aaa
bbb
aaa
bbb
aaa
bbb

创建线程

package org.example.a;

public class Demo{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class !");
            }
        }).start();

        new Thread(() -> System.out.println("Lambda !")).start();
    }
}

执行结果

Anonymous Internal Class !
Lambda !

排序

package org.example.a;

import java.util.Arrays;
import java.util.Comparator;

public class Demo{
    public static void main(String[] args) {
        String[] players = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka"};

        Arrays.sort(players, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return (o1.compareTo(o2));
            }
        });

//        Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
//        Arrays.sort(players, sortByName);

//        Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));

        for(String string:players){
            System.out.println(string);
        }
    }
}

执行结果(换成注释掉的两种任意一种都是一样的)

Novak Djokovic
Rafael Nadal
Stanislas Wawrinka

以上就是Java中Lambda表达式的使用详细教程的详细内容,更多关于Java Lambda表达式的资料请关注我们其它相关文章!

(0)

相关推荐

  • 关于Java 中的 Lambda 表达式

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

  • Java Lambda表达式超详细介绍

    目录 一.背景 1.Lambda表达式的语法 2.函数式接口 二.Lambda表达式的基本使用 三.语法精简 四.变量捕获 五.Lambda在集合当中的使用 1.Collection接口 六.List接口 1.sort()方法的演示 七.Map接口 一.背景 Lambda表达式是Java SE 8中一个重要的新特性.lambda表达式允许你通过表达式来代替功能接口. lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块). L

  • Java中Lambda表达式用法介绍

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

  • Java十分钟精通Lambda表达式

    目录 1.简介 2.Lambda表达式的使用: 1.在普通方法内的使用 2.带参方法的使用 3.Lambda表达式实现多线程 4.Lambda表达式操作运算 5.Lambda表达式方法引用 6.Lambda表达式对集合的使用 3.总结 1.简介 首先Lambda表达式是属于Java8的 一个新特性,提供Java编程中对于函数式编程的支持,有助于代码的简洁,可以取代大半部分的匿名函数,尤其对于集合的遍历和集合的操作,极大的简化了代码. Lambda表达式的主体: 函数式接口: 注意: Lambda

  • Java Lambda表达式常用的函数式接口

    失去人性,失去很多:失去兽性,失去一切.——<三体> 在Java8支持Lambda表达式以后,为了满足Lambda表达式的一些典型使用场景,JDK为我们提供了大量常用的函数式接口.它们主要在 java.util.function 包中,下面简单介绍几个其中的接口及其使用示例. Supplier接口 Supplier接口是对象实例的提供者,定义了一个名叫get的抽象方法,它没有任何入参,并返回一个泛型T对象,具体源码如下: package java.util.function; @Functio

  • 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; /**

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

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

  • 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表达式基础及使用

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

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

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

随机推荐