lambda表达式（jdk8才开始出现的语法）

1、是为了简化某些场景下匿名对象的繁琐。其中有一种函数式编程（强调做什么，而不是强调谁去做）的思想。

语法格式：

（形参列表） ->（固定格式）{

​ 方法体;

}

测试代码如下所示：

import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        /**
         * lambda表达式
         *  简化匿名对象的代码
         * */

        Product p1 = new Product(249, "鼠标");
        Product p2 = new Product(249, "电脑");
        Product p3 = new Product(2349, "显示器");
        Product p4 = new Product(549, "键盘");

        Product[] products = new Product[]{p1, p2, p3, p4};


        //使用传统方法
        Arrays.sort(products, new Comparator<Product>() {
            @Override
            public int compare(Product o1, Product o2) {
                return Double.compare(o1.getPrice(),o2.getPrice());
            }
        });

        for (int i = 0; i < products.length; i++) {
            System.out.println(products[i].toString());
        }

        System.out.println("---------------------------------");

        //使用lambda表达式简化代码
        Arrays.sort(products,(Product o1, Product o2) -> {
            return -(Double.compare(o1.getPrice(),o2.getPrice()));
        });

        for (int i = 0; i < products.length; i++) {
            System.out.println(products[i].toString());
        }


    }
}


class Product implements Comparable{
    private double price;
    String name;


    public Product() {
    }

    public Product(double price, String name) {
        this.price = price;
        this.name = name;
    }

    /**
     * 获取
     * @return price
     */
    public double getPrice() {
        return price;
    }

    /**
     * 设置
     * @param price
     */
    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "Product{price = " + price + ", name = " + name + "}";
    }

    @Override
    public int compareTo(Object o) {
        if (o == this){
            return 0;
        }
        if(o instanceof Product){
            Product p = (Product)o;
            int value = 0;
            value = Double.compare(this.price,p.getPrice());
            if(value != 0){
                return value;           //如果值不等于零，表示两个价格不同，则返回比较的信号值
            }
            return this.name.compareTo(p.name);     //否则则进行名称的比较
        }else
            throw new RuntimeException("类型错误!");
    }
}

2、注意：lambda表达式只能简化函数式接口（有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@Functionallnterface注解）的匿名内部类的写法。

3、lambda表达式的省略规则

①、参数类型可以省略不写

②、如果只有一个参数，参数类型可以省略，同时（）也可以省略

③、如果lambda表达式的方法只有一行，大括号，分号，return可以省略不写，但是需要同时省略，不能只省略某个。