java代码之美（1）---Java8 Lambda

时间 2020-02-11

标签 java 代码之美 java8 lambda 栏目 Java 繁體版

原文原文链接

Lambda

1、概述

一、什么是Lambda表达式

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

它能够写出更简洁、更灵活的代码。做为一种更紧凑的代码风格，使 Java 语言的表达能力获得了提高。java

二、Lambda表达式的语法

基本语法: (parameters) -> expressionexpress

或者：(parameters) ->{ statements; 数组

举例说明：app

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

三、什么是函数式接口

再对上面进行举例说明以前，必须先来理解下函数式接口，由于Lambda是创建在函数式接口的基础上的。ide

记住！
函数

（1）只包含一个抽象方法的接口，称为函数式接口。post

（2）你能够经过 Lambda 表达式来建立该接口的对象。this

（3）咱们能够在任意函数式接口上使用 @FunctionalInterface 注解，这样作能够检测它是不是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。url

在实际开发者有两个比较常见的函数式接口：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表达式，

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

2、方法引用

一、基本介绍

首先注意：方法引用，不是方法调用！方法引用，不是方法调用！方法引用，不是方法调用！

函数式接口的实例能够经过 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);

二、分类

类别	使用形式
静态方法引用	类名 :: 静态方法名
实例方法引用	对象名(引用名) :: 实例方法名
类方法引用	类名 :: 实例方法名
构造方法引用	类名 :: 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

参考

一、Java中Lambda表达式的使用

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

3、java8 笔记 - 方法引用（四）

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