六、lambda 表达式

总结:

对于只有一个抽象方法的接口需要实现这种接口的对象时可以使用 lambda 表达式
使用 lambda 表达式时， this 仍指向 lambda 表达式的外部，而使用匿名类的时候， this 指向匿名类，类似 javascript 的 ()=>{ } 这种写法
lambda 表达式使用的外部变量必须是 final 的（匿名类也是），不能修改，在 JDK 8 中，系统会自动为在 lambda 表达式内部使用的外部变量添加 final 修饰，这个功能被叫做 effectively final
lambda 表达式是运行时动态生成的，而匿名类是由编译器提前编译好了,会生成对应的 class 文件

package org.example.domain;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Dog {

    public static void shout(ShoutAble shoutAble) {
        System.out.println("??");
        shoutAble.shout("汪汪");
    }

    public static void main(String[] args) {


        ShoutAble s=(String s1)->{
            System.out.println(s1+"s1 哈哈");
        };
        Dog.shout(s);

        // 对于只有一个抽象方法的接口 需要这种接口的对象时 可以使用 lambda 表达式
        Dog.shout((String s2)->{
            System.out.println(s2+"s2 哈哈");
        });


        // 如果可以推导出 lambda 表达式的参数类型，可以忽略参数类型，
        // 如果只有一个参数且参数类型可以推导出，可以省略小括号
        Dog.shout( s3->{
            System.out.println(s3+"s3 哈哈");
        });


        // 只有一句话时可以省略 花括号，省略花括号的时候分号也要省略

        Dog.shout(s4-> System.out.println(s4+"s4 哈哈"));
        
        
        //public final int updateAndGet(IntUnaryOperator updateFunction) {
        //public interface IntUnaryOperator {int applyAsInt(int operand);}        
        // 若需要有返回值时，只有一句话 return xx.(yy); ,省略花括号的时候,return 也要省略        
        AtomicInteger largest=new AtomicInteger();
        largest.updateAndGet(x->Math.max(x,observed));
        

        
        
        Dog.shout(new ShoutAble() {
            @Override
            public void shout(String content) {
                System.out.println("匿名接口实现"+content);
            }
        });

    }
}

interface ShoutAble{

    void shout(String content);

}

/*

 */
引用：把已经存在的代码块直接哪来用
方法引用
    System.out::println  等价  x->System.out.println(x)
    Math::pow            等价  (x,y)->Math.Pow(x,y)
    String::compareToIgnoreCase 等价 (x,y)->x.compareToIgnoreCase(y)
构造器引用        
    Person::new          等价  根据上下文，自动选择一个构造器的引用

在 java.util.function 包下有许多常用的只有一个抽象方法的接口

public interface BiFunction<T, U, R> 
抽象方法的参数有两个 T 和 U  ，返回值为 R

public interface Function<T, R> {
抽象方法的参数有一个 T   ，返回值为 R
    
public interface IntFunction<R> {  R apply(int value);
抽象方法参数类型为 int 返回值为 R                                 
    
public interface ToIntFunction<T> {  int applyAsInt(T value);
抽象方法参数类型为 T 返回值为 int