1.Lambda表达式

Lambd表达式可以理解为一种可传递的匿名函数。它没有名称，但有参数列表、函数主体、返回类型，还有可能会抛出异常。在package java.util中有一个接口,接着创建苹果类：

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    ...
}
public class Apple {
    private int weight;
    private String color;

    public Apple(int weight, String color) {
        this.weight = weight;
        this.color = color;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

        匿名类的表达形式：

Comparator<Apple> appleComparator = new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return o1.getWeight()-o2.getWeight();
            }
};

        Lambda表达式形式：

Comparator<Apple> appleComparator1 = (Apple apple1, Apple apple2)->
                apple1.getWeight()-apple1.getWeight();

         可以看到Lambda表达式更简单:

                1. ()->{}  无参，{}做处理；

                2.（)->retrun 值; 无参，返回值；

                3.（String s）->s 有参，返回值；

                4.（String s）->{} 有参，做处理。

2.函数式接口

        只定义一个抽象方法的接口。它就是函数式接口。@FuntionallInterface注解，表示会设计成一个函数接口，不符合规范，会编译报错。

        jdk8 自定义了简单的四个函数式接口：

@FunctionalInterface
public interface Predicate<T> {
    //接收一个参数t，返回boolean
    boolean test(T t);
    //创建predicate实例， predicate.and(other),
                         结果为 predicate.test(t) and other.test(t)
    default Predicate<T> and(Predicate<? super T> other)；
    
    //创建predicate实例， predicate.or(other),
                         结果为 predicate.test(t) or other.test(t)
    default Predicate<T> or(Predicate<? super T> other)；
    
    //创建predicate实例， predicate.negate()
                         结果为 !predicate.test(t)
    default Predicate<T> negate()
    
    // Predicate.isEuqal("true").test("true")    
    static <T> Predicate<T> isEqual(Object targetRef) 
}

对应的测试结果：

Predicate<String>  predicate1=s->Boolean.parseBoolean(s);
System.out.println(predicate1.test("true")); //true
System.out.println(predicate1.and(s -> Boolean.parseBoolean(s)).test("false"));//false
System.out.println(predicate1.or(s -> Boolean.parseBoolean(s)).test("false"));//false
System.out.println(predicate1.negate().test("true"));//false
System.out.println(Predicate.isEqual("true").test("true"));//true

@FunctionalInterface
public interface Consumer<T> {

    //接受一个参数t
    void accept(T t);

    //创建一个consumer实例， consumer.andThen(after)
                            结果 先运行consumer.accept(t) ,接着运行 after.accept(t)
    default Consumer<T> andThen(Consumer<? super T> after);
}

对应的测试结果：

Consumer<String> consumer= s-> System.out.println(s+"1");
consumer.accept("1");//11
consumer.andThen(s-> System.out.println(s+"2")).accept("1");//输出11 换行12

@FunctionalInterface
public interface Function<T, R> {

    //输入t，返回r
    R apply(T t);
    
    //创建一个function实例， r= function.compose(before)
                            的结果 t = before.apply(v)； r=function.apply(t)
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before)；
    
   //创建一个function实例， r=function.andThen(after)
                            的结果 v = function.apply(t); r=after.apply(v)
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after);
    
   //t = Function.identity().apply(t)
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

对应的测试结果：

Function<String,String> function = s-> s+"1";
System.out.println(function.apply("1"));//11
System.out.println(function.andThen(s -> s + "2").apply("1"));//112
System.out.println(function.compose(s -> s + "2").apply("1"));//121
System.out.println(Function.identity().apply("1"));//1

@FunctionalInterface
public interface Supplier<T> {
    //返回T类型
    T get();
}

对应的测试结果：

Supplier<String> supplier = ()->"1";
System.out.println(supplier.get());//1

3.方法引用

 3.1 类名::静态方法名

 3.2 instance::instance方法名

 3.3 类名::instance方法名

 3.4 类名::new

[1]: Java8 实战 java 8 in Action Mario Fusco 著 Alan Mycroft 陆明刚 劳佳 译

一、排序示例

• 升序–> 从小到大
• 降序–> 从大到小
• age --> 排序字段
• jdk8 -> Lambda 循环打印println -> list.forEach(System.out::println);

1、jdk8 -> 之前的排序(升序)

        Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getAge().compareTo(o2.getAge());
            }
        });

2、jdk8 -> Lambda排序（升序）

//  不带参  
list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge()));        
//  带参
list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));  

3、jdk8 -> Comparator 提供的静态方法排序（ 升序）

 Collections.sort(list, Comparator.comparing(User::getAge));

4、jdk8 -> Comparator 提供的静态方法排序（ 降序）.reversed()

Collections.sort(list, Comparator.comparing(User::getAge).reversed());

5、jdk8 -> 组合排序

支持每个排序字段的结尾添加.reversed() 改为降序

// Age-升序   Name-升序
Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName));

// Age-升序   Name-降序
Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName).reversed());

// Age-降序   Name-升序
Collections.sort(list, Comparator.comparing(User::getAge).reversed() .thenComparing(User::getName));

// Age-降序   Name-降序
Collections.sort(list, Comparator.comparing(User::getAge).reversed() .thenComparing(User::getName).reversed());

二、完整测试代码参考

package com.ws.ldy.common.utils;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class JDK8ListSort {

    public static void main(String[] args) {


        // TODO jdk8 之前的排序
        System.out.println("============jdk8 之前的排序");
        List<User> list = initList();
        Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getAge().compareTo(o2.getAge());
            }
        });
        list.forEach(System.out::println);


        // TODO jdk8 lambda 排序-升序
        System.out.println("============jdk8 lambda排序，升序排序 --> 从小到大");
        list = initList();
        list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge()));   //不带参  带参: list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));
        list.forEach(System.out::println);


        // TODO jdk8 升序排序
        System.out.println("============jdk8 升序排序 --> 从小到大，Comparator提供的静态方法");
        list = initList();
        Collections.sort(list, Comparator.comparing(User::getAge));
        list.forEach(System.out::println);


        // TODO jdk8 降序排序
        System.out.println("============jdk8 降序排序 --> 从大到小，Comparator提供的静态方法");
        list = initList();
        Collections.sort(list, Comparator.comparing(User::getAge).reversed());
        list.forEach(System.out::println);
        System.out.println();


        // TODO jdk8 组合排序
        System.out.println("============jdk8 组合排序，Comparator提供的静态方法，先按年纪排序，年纪相同的按名称排序");
        list = initList();
        Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName));
        list.forEach(System.out::println);

    }


    /**
     * TODO  初始化List数据
     *
     * @return java.util.List<com.ws.ldy.common.utils.JDK8ListSort.User>
     * @author ws
     * @mail 1720696548@qq.com
     * @date 2020/5/10 0010 22:49
     */
    private static List<User> initList() {
        List<User> list = new ArrayList<>();
        list.add(new User("lisa", 23));
        list.add(new User("tom", 11));
        list.add(new User("john", 16));
        list.add(new User("jennis", 26));
        list.add(new User("tin", 26));
        list.add(new User("army", 26));
        list.add(new User("mack", 19));
        list.add(new User("jobs", 65));
        return list;
    }


    /**
     * TODO  测试对象
     *
     * @author ws
     * @mail 1720696548@qq.com
     * @date 2020/5/10 0010 22:49
     */
    @Data
    @AllArgsConstructor
    public static class User implements Serializable {
        private String name;
        private Integer age;
    }
}

1.接口增强

在JDK8之前，JDK规定接口中只能定义 ①静态常量  ②抽象方法

修饰词 interface 接口名{
    静态常量;
    抽象方法;
}

在JDK8之后，对接口进行了增强。我们可以在接口中定义 ①静态常量   ②抽象方法   ③默认方法    ④静态方法

修饰词 interface 接口名{
    静态常量;
    抽象方法;
    默认方法;
    静态方法;
}

2.为什么要对接口增强

 1.为什么要引入默认方法？

        实例1：我们在接口 A 中定义了个 test1() 抽象方法，现在有类 B、类 C 都实现了接口 A 。但是现在因为要接入新的需求，而这一个抽象方法明显不能够满足新需求。那么则需要在接口 A 中重新顶一个 test2() 抽象方法，此时我们发现类 B 、类 C 都因为没有实现新的抽象方法 test2() 而报错了。。。。。

        实例2：JDK8 在 Map 接口中增加了 forEach 方法。按 JDK8 之前标准，定义 forEach() 方法如下所示：

public interface Map<K,V>{
    ...
    abstract void forEach(BiConsumer<? super K, ? super V> action);
}

我们通过 API 可以查询到 Map 接口的实现类如下所示：

       此时，如果在 Map 接口中增加一个 forEach() 抽象方法，那么所有的这些实现类都需要来实现 forEach()方法，从而保证语法正确不报错，显然这工程量是巨大的，而且代码也会有很大的冗余。

       因此，在 JDK8 时为接口新增了默认方法（default修饰），效果如下：

public interface Map<K,V>{
    ...
    default void forEach(BiConsumer<? super K, ? super V> action){
        ...
    }
}

特性：

    1.新增的默认方法实现类不必重写，可以直接使用；

    2.实现类也可以根据需要重写       ---->这样就方便了接口的扩展。​​​​​​

 2.接口静态方法

     为了方便接口的扩展，JDK8 同时为接口新增了静态方法

特性：

    1.接口中的静态方法，实现类既不能调用，也不能重写；(只属于接口本身)

    2.只能通过接口名. (接口名+ .)的方式调用

3.默认方法、静态方法的定义

//默认方法的定义(使用 default 定义)
修饰符 interface 接口名{
    修饰符 default 返回值类型 方法名(){
        代码部分;
    }
}

//静态方法的定义(使用 static 修饰)
修饰符 interface 接口名{
    修饰符 static 返回值类型 方法名(){
        代码部分;
    }
}

4.默认方法 和 静态方法 的区别

1.默认方法通过实例调用，静态方法通过接口名调用

2.默认方法可以被继承，实现类可以直接使用接口默认方法，也可以重写接口默认方法

3.静态方法不能被继承，实现类不能重写接口静态方法，只能使用接口名调用。

5.Demo（这很简单，Demo就省了）

    谢谢

附：JDK8新特性（目录）

       本目录为 JDK8新特性 学习目录，包含JDK8 新增全部特性的介绍。

       如需了解，请跳转链接查看：我是跳转链接

博主写作不易，来个关注呗

求关注、求点赞，加个关注不迷路 ヾ(◍°∇°◍)ﾉﾞ

博主不能保证写的所有知识点都正确，但是能保证纯手敲，错误也请指出，望轻喷 Thanks♪(･ω･)ﾉ