Lambda表达式

Lambda是简洁的标识可传递匿名函数的一种方式。“互动”事件驱动下，最终面向对象编程和函数式编程结合才是趋势。 java中，一段代码的传递并不容易。因为JAVA是面向对象的语言，如果要传递一段代码，必须先构建类，再生成对应的对象来传递所要的代码。在之前，JAVA的设计者都抗拒加入这一特性，虽然JAVA现有的特性也能通过类和对象实现类似的API但是这样复杂且不易于使用。在后期，问题早已不是JAVA是不是要变成一门使用函数式编程的语言，而是如何实现这种改变。在java8之前已经有了多年的实验，然后JAVA8来了。

JAVA8新特性指路：
0.理解代码参数化和函数式编程
1.全新的时间API
2. optinal的用法
3. lambda表达式
4.Stream流

---

特性

1. 匿名：lambda表达式不像面向对象的方法一样，有确定的名称。
2. 函数：虽然lambda不是对象的方法，属于某个特定的类。但是lambda表达式一样的有参数列表、函数主体 返回类型和异常声明
3. 传递：lambda表达式可以作为参数传递
4. 简洁：无需像匿名类一样有固定模板的代码，lambda写得少而想得多
5. JAVA8中 可以为接口增加静态方法、可以为类增加默认方法

一、lambda表达式介绍

1.1 lambda表达式结构:

1.2 常见的Lambda表达式

//1、单个参数
(String s)->s.length()
//2、单个对象
(Apple a)->a.getWeight()>150
//3、多参数,多语句
(int a,int b)->{
	System.out.println(a);
	System.out.println(b);
}
//4、空参数,返回int值42
()->42
//5、多对象参数
(Applea1,Applea2)->a1.getWeight().compareTo(a2.getWeight())

1.3 基本语法

• (参数…）-> 表达式 隐式返回表达式结果

• (参数…)->{执行语句} 可用return语句 显示返回执行结果

• 函数式接口不允许抛出受检异常

• 注意：当参数只有一个时，也可以去掉参数的括号。原因是java编译器的自动类型推断
  
  
  

1.4 类型检查

1. Lambda的类型由上下文推断而来

2. 同样的lambda表达式，不同的函数式接口，只要方法的签名一致，同样的表达式可以用于不同的函数是接口。

3. 只有函数式接口的实现，能承载lambda表达式

4. Objecto=()-{System.out.print("HellowWorld")} 这是不合法的 因为Object不是一个函数式接口
   
   
   

1.5 类型推断

1. Lambda表达式可以省略参数的类型，java编译器能自动推断

2. 当lambda只有一个参数需要推断类型时，参数两边的括号可以省略

List<Apple> c=filter(inventory,a->"green".equals(a.getColor()));
Comparator<Apple> c=(a1,a2)->a1.getWeight.compareTo(a2.getWeight());

1.6 变量作用域

JAVA8之前 内部类只允许访问final修饰的变量，现在使用lambda表达式，一个内部类可以访问任何有效的final局部变量-任何值不会发生变化的变量

1. java限制了 lambda表达式访问的自由变量，值是不可更改的，因为这会导致出现无法预料的并发问题。

2. java编译器的限制是有限的，只对局部变量有效，如果使用静态变量，或者示例变量，编译器不会提示任何错误。这样仍然是不安全的。

3. 可以用数组 int[] counter =new int[1]; button.setOnAaction(event->counter[0]++); 任然可以让lambda对局部变量进行重新赋值。

4. lambda表达式的方法体，与被嵌套的代码块具有同样的作用域，所有适用同样的命名冲突和变量屏蔽规则。

1.7 方法引用

对于已有的方法，如果希望作为lambda表达式来使用，可以直接使用方法引用

三种方法引用的情况

1. 对象：：实例方法
2. 类：：静态方法
3. 类：：实例方法

在第一种和第二种方法引用种，方法的引用等于提供方法参数的lambda表达式
例如：

• System.out::println() 等同于 System.out.print(x)
• Math::pow 等同于 （x,y）->Math.pow(x,y)

对于第三种，则相当于第一个参数成为执行方法的对象
例如：String::compareToIngnoreCase 等同于（x,y） x.compareIngoreCase（Y）；

1.8 构造器引用

对于构造器引用，相当于根据构造器的方法的参数，生成一个构造的对象的一个lambda表达式
例如：StringBuilder::new 可以表示为 (Stiring s)->new StringBuilder(s); 具体引用哪个构造器，编译器会根据上下文推断使用符合参数的构造器。

二、在何处使用lambda表达式

2.1 函数式接口介绍

总结：就是只定义了一个抽象方法的接口，即使有一堆的default方法（default方法是为了增强某些API但避免现有大范围改动所有API所以推出了默认方法）

不同接口的默认方法冲突问题
如果实现的接口已有一个默认方法，但是另一个父类或者接口也有同样的默认方法。

1. 如果是父类和接口默认方法一致，那么直接使用父类的方法实现，忽略接口中的默认方法(类优先规则，如果尝试重写默认方法toString 那么永远都不会优于Object的toString)
2. 如果一个父接口提供了一个默认方法，另一个接口也提供了同名称和参数的方法(不论是否默认方法)那么都必须覆盖改方法。

其他:
接口中重写Object类的方法，例如 Comparator 一般是为了关联javadoc的注释。

2.2 常见的函数式接口

介绍：函数式接口的抽象方法的签名，基本就是lambda表达式的签名，这种抽象方法称为 函数描述符

Predicate接口

方法签名为，输入某个对象 返回布尔结果

	/**
     * java.util.Predicate 是一个只有test方法，返回布尔值的一个函数式接口，
     * 与其类似的还有用于比较，排序的Comparator接口，其只有一个返回整数的比较接口
     * @param list
     * @param p
     * @param <T>
     * @return
     */
    public static <T> List<T> filter(List<T> list, Predicate<T> p){
        List<T> result=new ArrayList<>();
        for (T t : list) {
            if (p.test(t))
                result.add(t);
        }
        return result;
    }

    public static void main(String[] args) {
        //Predicate函数式接口示例
        List<Apple> appleList=new ArrayList<>();
        List<Apple> resulAppleList=filter(appleList,(Apple a)->a.getColor().equals("red"));
    }

Counsumer接口

Accept （）方法签名为，输入某个对象 返回void

	/**
     * 常用2：Consume
     * consume接口定义了一个 名为accept的抽象方法，接收泛型 T 返回void
     * 可用来访问T类型的对象，并且执行某些操作。
     * 如下用其创建，一个foreach方法，可以实现对所有List的遍历。且对每个对象执行consume定义的操作。
     * 该foreach方法，java8之后成了List接口的default方法。
     * @param list
     * @param <T>
     */
    public static <T> void foreach(List<T> list, Consumer<T> consumer){
        for (T t : list) {
            consumer.accept(t);
        }
    }
	
	
 //Consume函数式接口示例,遍历列表执行某项操作
foreach(appleList,(Apple a)->{if (a.getColor()==null);a.setColor("garly");});
appleList.forEach((Apple a)->{if (a.getColor()==null);a.setColor("garly");});

Function接口

Apply（） 方法签名：输入某个对象、返回某个对象

	Apply（） 方法签名：输入某个对象、返回某个对象
	//使用举例
    public static void main(String[] args) {
        List<Apple> appleList =new ArrayList<>();
        appleList.add(new Apple("红色",11));
        appleList.add(new Apple("蓝色",11));
        //接下来，骚操作一行代码提取APple的颜色
        List<String> allColor=map(appleList,(Apple a)->a.getColor());
    }


    /**
     * 示范 函数式接口Function 的实例
     * function.apply() 接收T,返回R 可将一种对象处理成另一种对象
     * @param list
     * @param function
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T,R> List<R> map(List<T> list,Function<T,R> function){
        List<R> result=new ArrayList<>();
        list.forEach((T t)->{result.add(function.apply(t));});
        return result;
    }

2.3 常见的Lambda和已有的实现

案例	Lambda例子	对应的函数式接口
布尔表达式	(List list) ->list.isEmpty()	Predicate<List
创建对象	（）->new APPle()	Supplier
消费一个对象	（Apple a->{sout(a.getColor());}	Consumer
从一个对象中提取	（Apple a）>a.geWeight（）	Function 或者其特殊化的 ToIntFunction
合并两个值	（int a,int b）->a+b	IntBinaryOperator
比较两个对象	(Apple a1,Apple a2)->a1.getWeight（）.compareTo(a2.getWeight（）)	Comparator BigFunction<Apple，Apple,Integer> ToIntBigFunction<Apple,Apple>

2.4 针对装箱拆箱的优化

java的基本类型和引用类型之间，会自动的进行拆箱装箱，但是本质是吧原始类型包裹起来再保存在堆内存，所以装箱后需要更多内存。java位基本的类型定义了特有的函数式接口，一般只需要加上原始类型的前缀即可

输入基本类型的函数式接口：

1. DoublePredict、IntConsumer、LongBinaryOperate

输出基本类型的函数式接口：

1. ToIntFunction

2.5 复合Lambda函数

	List<Apple>apples=newArrayList<>();
	apples.add(newApple("red",11));
	apples.add(newApple("red",12));
	apples.add(newApple("green",13));
	
	/**
	*对排序lanmbda进行复复合-比较器链
	*1、默认逆序方法：reversed()
	*2、多级比较：thenComparing()
	*example:对apples按照颜色排序后，进行逆序，如果颜色一样再按照重量递增
	*/
	Comparator<Apple>comparator=Comparator.comparing(Apple::getColor).reversed().thenComparing(Apple::getWeight);
	apples.sort(comparator);
	
	
	/**
	*谓词复合且、或、非
	*1、negate否定
	*2、and且
	*3、or或
	*example：对不是红色的苹果进行过滤，且收集重量大于100的苹果
	*/
	Predicate<Apple>redApplePredicate=a->a.getColor().equals("red");
	Predicate<Apple>notRedApple=redApplePredicate.negate();
	List<Apple>notRedAppleList=apples.stream().filter(notRedApple.and(apple->apple.getWeight()>100)).collect(Collectors.toList());
	
	
	/**
	*函数复合
	*1、andThen将前一lambda执行结果，作为后一表达式的参数
	*2、compose将后一表达式的结果作为前一表达式的参数
	*example；complexReult=g(f(x))例如g(f(1))step1:1+1=2step2:(1+1)*2+""
	*/
	Function<Integer,Integer>f=x->x+1;
	Function<Integer,String>g=x->x*2+"";
	Function<Integer,String>complexResult1=f.andThen(g);