Lambda表达式

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口. lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码 块)。 Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭 包（Closure）

1. 基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }
2. Lambda表达式由三部分组成：
   1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明 也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
   2. ->：可理解为“被用于”的意思
   3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反 回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。

1. 定义:只有一个抽象方法的接口就叫函数式接口,但jdk1.8之后,该接口能允许有具体实现的方法,但这个方法必须是被default修饰
2. 可对接口加一个注解:@FunctionalIterface,好处在于编译期限制你接口里只写一个抽象方法

@FunctionalInterface
interface  NoParameterNoReturn{
    void test();

    default void display(){
        System.out.println("我是default方法,jdk1.8之后我可以进函数式接口啦");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new NoParameterNoReturn(){
            @Override
            public void test(){
                System.out.println("我对函数式接口的test()抽象方法在重写呢!");
            }
        }.test();
    }
}
//打印:我对函数式接口的test()抽象方法在重写呢!

1. 我们可以理解这个表达式是匿名内部类的一种等价表达
2. 整个表达式代表着一个类,这个类实现了什么接口我们必须提前知道,然后表达式的内容须是对这个接口的抽象方法进行的重写内容

如:main1中的匿名内部类,就可以表达成main函数中的Lambda表达式

@FunctionalInterface
interface  NoParameterNoReturn{
    void test();

    default void display(){
        System.out.println("我是default方法,jdk1.8之后我可以进函数式接口啦");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn tmp=()-> System.out.println("我对函数式接口的test()抽象方法在重写呢!");
        tmp.test();//多态式调用咯
        //也是打印"我对函数式接口的test()抽象方法在重写呢!"
    }
    public static void main1(String[] args) {
        new NoParameterNoReturn(){
            @Override
            public void test(){
                System.out.println("我对函数式接口的test()抽象方法在重写呢!");
            }
        }.test();
    }
}

1. .参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略 3
3. 如果方法体当中只有一句代码，那么大括号可以省略 4
4. 如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且还可去掉return关键字。

1. 匿名内部类定义:没有名字的内部类

2. 匿名内部类的注意事项:

   1、匿名内部类不能定义任何静态成员、方法。
   2、匿名内部类中的方法不能是抽象的；
   3、匿名内部类必须实现接口或抽象父类的所有抽象方法。
   4、匿名内部类不能定义构造器；
   5、匿名内部类访问的外部类成员变量或成员方法必须用static修饰；
   6、内部类可以访问外部类私有变量和方法。

3. 匿名内部类的变量捕获

   class Test {
       public void func(){
       System.out.println("func()");
       }
   }
   public class TestDemo {
   	public static void main(String[] args) {
   		int a = 100;
   		new Test(){
   			@Override
   			public void func() {
   			System.out.println("我是内部类，且重写了func这个方法！");
   			System.out.println("我是捕获到变量 a == "+a
   			+" 我是一个常量，或者是一个没有改变过值的变量！");
   			}
   		};
   	}
   }
   
   

4. a在TestDemo中不可被修改过,或者是被final修饰了也行,这样才会默认捕获到a,如果不是直接编译出错

与匿名内部类捕获是一样的,因为上面提到了,匿名内部类的等价表达就是Lambda表达式

1. 如forEach()方法:(可见forEach的形参是一个Consumer接口)

   default void forEach(Consumer action) {
   	Objects.requireNonNull(action);
   	for (T t : this) {
   		action.accept(t);
   	}
   }
   

2. 如果用一个匿名内部类实现Consumer接口,并对accept方法进行重写

   public class TestDemo {
       public static void main(String[] args) {
           ArrayList arrayList=new ArrayList<>();
           arrayList.add("hello");
           arrayList.add("to");
           arrayList.add("my");
           arrayList.add("world");
           arrayList.forEach(new Consumer() {
               @Override
               public void accept(String s) {
                   System.out.print(s+" ");
               }
           });
       }
   }
   //解释一下:匿名内部类做形参,被Consumer接口接受,即发生向上转型,通过观察Collection的forEach方法可知:
   //forEach方法将使用for-each循环去遍历调用forEach方法的对象,遍历到的元素将会被作为形参传至accept方法中
   //那通过Consumer类型的action调用accept方法,其实是多态式调用,调用了我们重写的accept(),所以分析完就知道
   //等价于将顺序表的元素逐一打印
   //hello to my world 
   

3. 使用Lambda表达式来写

   public class TestDemo {
       public static void main(String[] args) {
           ArrayList arrayList=new ArrayList<>();
           arrayList.add("hello");
           arrayList.add("to");
           arrayList.add("my");
           arrayList.add("world");
           arrayList.forEach((s)-> System.out.print(s+" "));
           
       }
   }
   //可见表达式大大简化,但是可读性就比较差了,我们能写出来是因为我们知道我们的Lambda在表达谁
   //此时表达的就是匿名内部类里的重写的匿名函数
   

   ---

1. sort()

   default void sort(Comparator c) {
           Object[] a = this.toArray();
           Arrays.sort(a, (Comparator) c);
           ListIterator i = this.listIterator();
           for (Object e : a) {
               i.next();
               i.set((E) e);
           }
       }
   //只需要知道两点
   //1:sort的形参是一个Comparator接口
   //2:sort会根据我们给的比较器去排序线性结构中的成员
   

2. 针对sort()我们可以与Collection的forEach()类似,给sotr()传一个匿名内部类做比较器咯

   public class TestDemo {
       public static void main(String[] args) {
           List list=new ArrayList<>();
           list.add("hello");
           list.add("to");
           list.add("my");
           list.add("world");
           list.sort(new Comparator() {
               @Override
               public int compare(String o1, String o2) {
                   return o1.compareTo(o2);//升序
               }
           });
           System.out.println(list);
       }
   }
   

又如Map也也有forEach(),用法类似,不作赘述.

1. 优点:
   1. 代码简洁，开发迅速
   2. 方便函数式编程
   3. 非常容易进行并行计算
   4. Java 引入 Lambda，改善了集合操作
2. 缺点:
   1. 代码可读性变差
   2. 在非并行计算中，很多计算未必有传统的 for 性能要高
   3. 不容易进行调试