Lambda

一、概述

1、什么是Lambda表达式

Lambda 表达式是一种匿名函数,简单地说,它是没有声明的方法,也即没有访问修饰符、返回值声明和名字。

它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使 Java 语言的表达能力得到了提升。

2、Lambda表达式的语法

基本语法:  (parameters) -> expression

或者:(parameters) ->{ statements;

举例说明:

// 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)

3、什么是函数式接口

再对上面进行举例说明之前,必须先来理解下函数式接口,因为Lambda是建立在函数式接口的基础上的。

 记住!

(1)只包含一个抽象方法的接口,称为函数式接口。

(2)你可以通过 Lambda 表达式来创建该接口的对象。

(3)我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检测它是否是一个函数式接口,同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。

在实际开发者有两个比较常见的函数式接口:Runnable接口,Comparator接口

先举例Runnable接口相关

public class Test {

    public static void main(String[] args) {

        // 1.1使用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello world !");
}
}).start(); // 1.2使用 lambda 获得Runnable接口对象
new Thread(() -> System.out.println("Hello world !")).start(); //============================================================================= // 2.1使用匿名内部类
Runnable race1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world !");
}
}; // 2.2使用 lambda直接获得接口对象
Runnable race2 = () -> System.out.println("Hello world !"); // 直接调用 run 方法(没开新线程哦!)
race1.run();
race2.run();
}
}
/*输出结果
* Hello world !
* Hello world !
* Hello world !
* Hello world !
*/

通过上面案例可以看出:通过Lambda表达式看去舒服清爽多了,2而通过匿名内部类代码总是不够整洁。

再举一个例子:使用Lambda对数组排序

public class TestArray {

    public static void main(String[] args) {
String[] players = {"zhansgan", "lisi", "wangwu", "zhaoliu", "wangmazi"}; // 1.1 使用匿名内部类根据 surname 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.compareTo(s2));
}
}); // 1.2 使用 lambda 排序,根据 surname
Arrays.sort(players, (String s1, String s2) -> s1.compareTo(s2)); //================================================================================================ // 2.1 使用匿名内部类根据 name lenght 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.length() - s2.length());
}
}); // 2.2使用Lambda,根据name length
Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length())); //================================================================================================== // 3.1 使用匿名内部类排序 players, 根据最后一个字母
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
}
}); // 3.2 使用Lambda,根据最后一个字母
Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));
}
}

通过上面例子我们再来思考为什么Lambda表达式需要函数式接口?其实很简单目的就是为来保证唯一。

你的Runnable接口只要一个抽象方法,那么我用() -> System.out.println("Hello world !"),就只能代表run方法,如果你下面还有一个抽象方法,那我使用Lambda表达式,

那鬼才知道要调用哪个抽象方法呢。

二、方法引用

1、基本介绍

首先注意:方法引用,不是方法调用!方法引用,不是方法调用!方法引用,不是方法调用!

函数式接口的实例可以通过 lambda 表达式、 方法引用、构造方法引用来创建。方法引用是 lambda 表达式的语法糖,任何用方法引用的地方都可由lambda表达式替换,

但是并不是所有的lambda表达式都可以用方法引用来替换。

举例

这就是一个打印集合所有元素的例子,value -> System.out.println(value) 是一个Consumer函数式接口, 这个函数式接口可以通过方法引用来替换。

public class TestArray {

    public static void main(String[] args) {
List<String> list = Arrays.asList("xuxiaoxiao", "xudada", "xuzhongzhong");
list.forEach(value -> System.out.println(value));
}
/* 输出:
* xuxiaoxiao
* xudada
* xuzhongzhong
*/
}

使用方法引用的方式,和上面的输出是一样的,方法引用使用的是双冒号(::)

list.forEach(System.out::println);

2、分类

类别 使用形式
静态方法引用 类名 :: 静态方法名
实例方法引用 对象名(引用名) :: 实例方法名
类方法引用 类名 :: 实例方法名
构造方法引用 类名 :: new

(1)静态方法引用

public class Apple {

    private String name;
private String color;
private double weight; public Apple(String name, String color, double weight) {
this.name = name;
this.color = color;
this.weight = weight;
} public static int compareByWeight(Apple a1, Apple a2) {
double diff = a1.getWeight() - a2.getWeight();
return new Double(diff).intValue();
} //还有getter setter toString
}

有一个苹果的List,现在需要根据苹果的重量进行排序。List 的 sort 函数接收一个 Comparator 类型的参数,Comparator 是一个函数式接口,接收两个参数,

返回一个int值。Apple的静态方法compareByWeight正好符合Comparator函数式接口,所以可以使用:

Apple::compareByWeight 静态方法引用来替代lambda表达式

public class LambdaTest {

    public static void main(String[] args) {

        Apple apple1 = new Apple("红富士", "Red", 280);
Apple apple2 = new Apple("冯心", "Yello", 470);
Apple apple3 = new Apple("大牛", "Red", 320);
Apple apple4 = new Apple("小小", "Green", 300); List<Apple> appleList = Arrays.asList(apple1, apple2, apple3, apple4); //lambda 表达式形式
//appleList.sort((Apple a1, Apple a2) -> {
// return new Double(a1.getWeight() - a2.getWeight()).intValue();
//}); //静态方法引用形式(可以看出引用方法比上面的更加简单
appleList.sort(Apple::compareByWeight); appleList.forEach(apple -> System.out.println(apple)); }
}
输出:
Apple{category='红富士', color='Red', weight=280.0}
Apple{category='小小', color='Green', weight=300.0}
Apple{category='大牛', color='Red', weight=320.0}
Apple{category='冯心', color='Yello', weight=470.0}

注意:Apple.compareByWeight是方法的调用,而Apple::compareByWeight方法引用,这两者完全不是一回事。

(2)实例方法引用

这个compareByWeight是一个实例方法

public class AppleComparator {

    public int compareByWeight(Apple a1, Apple a2) {
double diff = a1.getWeight() - a2.getWeight();
return new Double(diff).intValue();
}
}

下面的例子通过实例对象的方法引用 comparator::compareByWeight 来代替lambda表达式

public class LambdaTest {

    public static void main(String[] args) {

        Apple apple1 = new Apple("红富士", "Red", 280);
Apple apple2 = new Apple("冯心", "Yello", 470);
Apple apple3 = new Apple("哈哈", "Red", 320);
Apple apple4 = new Apple("小小", "Green", 300); List<Apple> appleList = Arrays.asList(apple1, apple2, apple3, apple4); //lambda 表达式形式
//appleList.sort((Apple a1, Apple a2) -> {
// return new Double(a1.getWeight() - a2.getWeight()).intValue();
//}); //实例方法引用
AppleComparator comparator = new AppleComparator();
appleList.sort(comparator::compareByWeight); appleList.forEach(apple -> System.out.println(apple)); }
}
输出:
Apple{category='红富士', color='Red', weight=280.0}
Apple{category='小小', color='Green', weight=300.0}
Apple{category='哈哈', color='Red', weight=320.0}
Apple{category='冯心', color='Yello', weight=470.0}

通过上面两个例子可以看到,静态方法引用和实例方法引用都是比较好理解的。

(3)类方法引用

一般来说,同类型对象的比较,应该当前调用方法的对象与另外一个对象进行比较,好的设计应该像下面:

public class Apple {

    private String category;
private String color;
private double weight; public Apple(String category, String color, double weight) {
this.category = category;
this.color = color;
this.weight = weight;
}
//这里和上面静态方式唯一区别就是这个参数就一个,需要实例对象调这个方法
public int compareByWeight(Apple other) {
double diff = this.getWeight() - other.getWeight();
return new Double(diff).intValue();
} //getter setter toString
}

还是之前List排序的例子,看看使用类方法引用如何写:

public class LambdaTest {

    public static void main(String[] args) {

        Apple apple1 = new Apple("红富士", "Red", 280);
Apple apple2 = new Apple("黄元帅", "Yello", 470);
Apple apple3 = new Apple("红将军", "Red", 320);
Apple apple4 = new Apple("国光", "Green", 300); List<Apple> appleList = Arrays.asList(apple1, apple2, apple3, apple4); //lambda 表达式形式
//appleList.sort((Apple a1, Apple a2) -> {
// return new Double(a1.getWeight() - a2.getWeight()).intValue();
//}); //这里是类方法引用
appleList.sort(Apple::compareByWeight); appleList.forEach(apple -> System.out.println(apple)); }
}
输出:
Apple{category='红富士', color='Red', weight=280.0}
Apple{category='国光', color='Green', weight=300.0}
Apple{category='红将军', color='Red', weight=320.0}
Apple{category='黄元帅', color='Yello', weight=470.0}

这里使用的是:类名::实例方法名。首先要说明的是,方法引用不是方法调用。compareByWeight一定是某个实例调用的,就是lambda表达式的第一个参数,然后lambda

表达式剩下的参数作为 compareByWeight的参数,这样compareByWeight正好符合lambda表达式的定义。

或者也可以这样理解:

(Apple a1, Apple a2) -> { return new Double(a1.getWeight() - a2.getWeight()).intValue(); }

int compareByWeight(Apple other) 需要当前对象调用,然后与另外一个对象比较,并且返回一个int值。可以理解为lambda表达式的第一个参数 a1 赋值给当前对象, 然后 a2

赋值给 other对象,然后返回int值。

(4)构造方法引用

public class ConstructionMethodTest {

    public String getString(Supplier<String> supplier) {
return supplier.get();
} public static void main(String[] args) { ConstructionMethodTest test = new ConstructionMethodTest(); //lambda表达式形式
System.out.println(test.getString(() -> { return new String();})); //构造方法引用形式
System.out.println(test.getString(String::new)); }
}

getString 方法接收一个Supplier类型的参数,Supplier 不接收参数,返回一个String。lambda表达式应该这样写:

() -> { return new String();}

替换成方法引用的形式如下: 实际上调用的是String 无参构造方法。

String::new

参考

1、Java中Lambda表达式的使用

2、java8特性概要以及demo分析

3java8 笔记 - 方法引用(四)

想太多,做太少,中间的落差就是烦恼。想没有烦恼,要么别想,要么多做。中校【9】

  

java代码之美(1)---Lambda的更多相关文章

  1. java代码之美(14)---Java8 函数式接口

    Java8 函数式接口 之前写了有关JDK8的Lambda表达式:java代码之美(1)---Java8 Lambda 函数式接口可以理解就是为Lambda服务的,它们组合在一起可以让你的代码看去更加 ...

  2. java代码之美(15)---Java8 Function、Consumer、Supplier

    Java8 Function.Consumer.Supplier 有关JDK8新特性之前写了三篇博客: 1.java代码之美(1)---Java8 Lambda 2.java代码之美(2)---Jav ...

  3. java代码之美(11)---java代码的优化

    java代码的优化 随着自己做开发时间的增长,越来越理解雷布斯说的: 敲代码要像写诗一样美.也能理解有一次面试官问我你对代码有洁癖吗? 一段好的代码会让人看就像诗一样,也像一个干净房间会让人看去很舒服 ...

  4. java代码之美(3)---guava 复写Object常用方法

    guava 复写Object常用方法 Guava 是一个 Google 的基于java1.6的类库集合的扩展项目,这个库提供用于集合,缓存,支持原语,并发性,常见注解,字符串处理,I/O和验证的实用方 ...

  5. java代码之美(10)---Java8 Map中的computeIfAbsent方法

    Map中的computeIfAbsent方法 Map接口的实现类如HashMap,ConcurrentHashMap,HashTable等继承了此方法,通过此方法可以在特定需求下,让你的代码更加简洁. ...

  6. java代码之美(2)---Java8 Stream

    Stream 第一次看到Stream表达式就深深把我吸引,用它可以使你的代码更加整洁而且对集合的操作效率也会大大提高,如果你还没有用到java8的Stream特性,那就说明你确实out啦. 一.概述 ...

  7. java代码之美(13)--- Predicate详解

    java代码之美(13)--- Predicate详解 遇到Predicate是自己在自定义Mybatis拦截器的时候,在拦截器中我们是通过反射机制获取对象的所有属性,再查看这些属性上是否有我们自定义 ...

  8. java代码之美(16) ---Java8 Optional

    Java8 Optional 一句话介绍Optional类:使用JDK8的Optional类来防止NullPointerException(空指针异常)问题. 一.前言 在我们开放过程中,碰到的异常中 ...

  9. java代码之美(12)---CollectionUtils工具类

    java代码之美(12)---CollectionUtils工具类 这篇讲的CollectionUtils工具类是在apache下的, 而不是springframework下的CollectionUt ...

随机推荐

  1. eclipse乱码解决

    设置utf-8 1.点击window>preferences>content types 2.点击右侧Text 3.点击Java Source File 4.下面输入UTF-8 5.点击u ...

  2. 并发编程 futuretask

    package com.mrbird.api.demoThread.future; import java.util.concurrent.Callable; import java.util.con ...

  3. stylus 样式

  4. DAY1 VS2017&CUDA10.01环境搭建

    Visual Studio工程配置情况: VC++目录配置: C:\ProgramData\NVIDIA Corporation\CUDA Samples\v10.\common\lib\x64 C: ...

  5. 给树莓派开启samba服务

    参考链接:https://www.cnblogs.com/mnstar/p/8144943.html 安装samba 和 samba-common-bin 启动树莓派以后,在命令行输入: sudo a ...

  6. SpringBoot使用Graylog日志收集

    本文介绍SpringBoot如何使用Graylog日志收集. 1.Graylog介绍 Graylog是一个生产级别的日志收集系统,集成Mongo和Elasticsearch进行日志收集.其中Mongo ...

  7. C# 0xC0000005 捕获

    [HandleProcessCorruptedStateExceptions]//捕获c++异常 [SecurityCritical]//捕获c++异常 public void xxx() { try ...

  8. 解决win10搜索框不能使用的问题

    1.首先,打开管理员命令窗口,win+x,可以看到弹出一个窗口,打开windows Powershell(管理员) 2,输入 Get-AppXPackage -Name Microsoft.Windo ...

  9. [POJ1273][USACO4.2]Drainage Ditches (网络流最大流)

    题意 网络流最大流模板 思路 EK也不会超时 所以说是一个数据比较水的模板题 但是POJ有点坑,多组数据,而且题目没给 哭得我AC率直掉 代码 用的朴素Dinic #include<cstdio ...

  10. tensor内部结构

    内部结构 1.tensor分为头信息区(Tensor)和存储区(Storage): 信息区:tensor的形状(size).步长(stride).数据类型(type),信息区占用内存较少 存储区:数据 ...