1.java8新特性之lambda表达式

1.lambda

Oracle官方文档
java8发布至今已经过去很久了，最近10也出来了，我们来深深体验下吧

供参考

（1）其实也就是匿名内部类,举个例子

 /**
     * 匿名内部类
     */
    @Test
    public void test1() {
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
    }

其实上述的代码只有Integer.compare(o1, o2)，有效则其它均可以省略

    /**
     * lambda表达式
     */
    public void test2(){
        Comparator<Integer> com = (o1, o2)->Integer.compare(o1, o2);
    }

2.四大内置核心函数式接口

1. 尽管匿名内部类有着种种限制和问题，但是它有一个良好的特性，它和Java类型系统结合的十分紧密：每一个函数对象都对应一个接口类型。我们使用lambda需要自定义interface去实现，使用是不是太墨迹，所以Java SE 8中增加了一个新的包：java.util.function，它里面包含了常用的函数式接口。
   

注解：@FunctionalInterface从该注解注释中 functional interface has exactly one abstract method，发现常用的一些接口Callable、Runnable、Comparator等在JDK8中都添加

(1)消费型接口

Consumer<T> ：void accept(T t);

    /**
     * 消费型
     */
    @Test
    public void test() {
        consume("斗罗大陆", x -> System.out.println("今天我看了" + x + "这本小说"));
    }

    public void consume(String book, Consumer<String> consumer) {
        //源码注释：对给定的参数执行此操作
        consumer.accept(book);
    }

(2)供给型接口

Supplier<T> :T get();

    /**
     * 供给型
     */
    @Test
    public void sutest() {
        sutest1(() -> 100);
    }

    @Test
    public void sutest1(Supplier<Integer> supplier) {
        //源码注释: Gets a result.
        Integer d = supplier.get();
        System.out.println("今天了看了" + d + "章小说。");
    }

(3)函数型接口

Function<T, R> : R apply(T t);

    /**
     * 函数型接口
     */
    @Test
    public void funaTest() {
        String a = funatest1("12345", (x) -> x.substring(0,3));
        System.out.println(a);
    }

    @Test
    public String funatest1(String str, Function<String, String> fun) {
        return fun.apply(str);
    }

(4)断言型接口

    /**
     * 断言型接口
     */
    @Test
    public void PreTest() {
        PreTest1(1001, x -> x >= 1000);
    }

    @Test
    public void PreTest1(Integer num, Predicate<Integer> pre) {
        if (pre.test(num)) {
            System.out.println("斗罗大陆我看完了");
        } else {
            System.out.println("斗罗大陆未看完了");
        }
    }

其他
Function接口相关的接口包括：

BiFunction ：R apply(T t, U u);接受两个参数，返回一个值，代表一个二元函数；

DoubleFunction ：R apply(double value);只处理double类型的一元函数；

IntFunction ：R apply(int value);只处理int参数的一元函数；

LongFunction ：R apply(long value);只处理long参数的一元函数；

ToDoubleFunction：double applyAsDouble(T value);返回double的一元函数；

ToDoubleBiFunction：double applyAsDouble(T t, U u);返回double的二元函数；

ToIntFunction：int applyAsInt(T value);返回int的一元函数；

ToIntBiFunction：int applyAsInt(T t, U u);返回int的二元函数；

ToLongFunction：long applyAsLong(T value);返回long的一元函数；

ToLongBiFunction：long applyAsLong(T t, U u);返回long的二元函数；

DoubleToIntFunction：int applyAsInt(double value);接受double返回int的一元函数；

DoubleToLongFunction：long applyAsLong(double value);接受double返回long的一元函数；

IntToDoubleFunction：double applyAsDouble(int value);接受int返回double的一元函数；

IntToLongFunction：long applyAsLong(int value);接受int返回long的一元函数；

LongToDoubleFunction：double applyAsDouble(long value);接受long返回double的一元函数；

LongToIntFunction：int applyAsInt(long value);接受long返回int的一元函数；
......

3.方法引用和构造器引用

我们可以简单的理解为：
方法引用：若lambda体中的内容已经实现了，我们可以使用"方法引用"---Lambda表达式的另外一种表现形式。
1）主要有三种语法格式

• 对象::实例方法名
• 类::静态方法名
• 类::实例方法名

1. 对象::实例方法名
   消费型，供给型

    @Test
    public void test1() {
        Consumer<String> con = (x) -> System.out.println(x);

        PrintStream p = System.out;
        Consumer<String> con1 = p::println;
        Consumer<String> con2 = System.out::println;
    }

---

    @Test
    public void test2() {
        Student stu = new Student();
        Supplier<String> supplier = () -> stu.getName();
        String str = supplier.get();
        System.out.println(str);

        Supplier<Integer> supplier1 = stu::getAge;
        Integer i  = supplier1.get();
        System.out.println(i);
    }

2.类::静态方法名

    /**
     * 类::静态方法名
     */
    @Test
    public void test3() {
        Comparator<Integer> com = (o1, o2) -> Integer.compare(o1, o2);

        Comparator<Integer> com1 = Integer::compare;
    }

3.类::实例方法名
当第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用Class::method

    /**
     * 类::实例方法名(条件苛刻)
     */
    @Test
    public void test4() {
        BiPredicate<String, String> bi = (x, y) -> x.equals(y);

        BiPredicate<String, String> bi1 = String::equals;
    }

---

构造器引用

Student.java

    /**
     * 构造器引用
     */
    @Test
    public void test5() {
        Supplier<Student> supplier = () -> new Student();

        Supplier<Student> supplier1 = Student::new;

        Function<String, Student> function = x -> new Student(x);

        Function<String, Student> function1 = Student::new;

    }

---

希望大家多多指点！！