JDK1.8新特性Lambda表达式

Lambda省去面向对象的条条框框，格式由3个部分组成：

• 一些参数

• 一个箭头

• 一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) ‐> { 代码语句 }

格式说明：

1. 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。

2. -> 是新引入的语法格式，代表指向动作。

3. 大括号内的语法与传统方法体要求基本一致。

Lambda省略格式

可推导即可省略

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略；

2. 如果小括号内有且仅有一个参，则小括号可以省略；

3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

（在Thread()括号里面Alt + /提示的第一个就是lamada表达式）

// 正常匿名内部类启动一个线程
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("正常启动线程");
    }
}).start();
 
// lamada表达式省略版启动一个线程
new Thread(() -> System.out.println("lamada表达式省略版启动线程")).start();
 
//lamada表达式标准版启动一个线程
new Thread(() -> {System.out.println("lamada表达式标准版启动线程");}).start();

Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。

无论是JDK内置的Runnable 、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一

时，才可以使用Lambda。

2. 使用Lambda必须具有上下文推断。

也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

 

根据返回类型有：

无参数无结果返回

/*
    定一个厨子Cook接口，内含唯一的抽象方法makeFood
*/
public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
}

（在括号中alt+/会提示lamada表达式）

/*
    需求:
        给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
        使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样
*/
public class Demo01Cook {
    public static void main(String[] args) {
        //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("传统makeFood");
            }
        });
 
        //使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了");
        });
 
        //优化省略Lambda
        invokeCook(()-> System.out.println(""lamada makeFood""));
    }
 
    //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

当给Cook再加一个方法就不能用lamada表达式了

有参数

// 将数组中的Persion年龄由大到小排列

public static void main(String[] args) {
    Persion[] array = {new Persion("jack", 18), new Persion("jack2", 17), new Persion("jack3", 20)};
    // 匿名内部类,由大到小排列
    Comparator<Persion> comparable = new Comparator<Persion>() {
        @Override
        public int compare(Persion p1, Persion p2) {
            return p2.getAge() - p1.getAge();
        }
    };
    Arrays.sort(array, comparable);
    for(Persion p:array) {
        System.out.println(p);
    }
 
    // lamada表达式（=后alt+/自动提示有lamada表达式）
    Comparator<Persion> comp = (o1, o2) -> o2.getAge() - o1.getAge();
    // 也可以写成标准版（变量的类型可以不加）
    Comparator<Persion> comp2 = (Persion o1, Persion o2) -> {
        return o2.getAge() - o1.getAge();
    };
 
    Arrays.sort(array, comparable);
    for(Persion p:array) {
        System.out.println(p);
    }
}

有结果返回

// 定义一个计算接口
public interface Calculator {
    int calc(int x, int y);
}
 
public class InvokeCalc {
    public static void main(String[] args) {
        //正常方式
        invoCacl(1, 2, new Calculator() {
            @Override
            public int calc(int x, int y) {
                return x + y;
            }
        });
 
        // lamada表达式省略版
        invoCacl(1, 2, (x, y) -> x + y);
        // lamada表达式标准版（变量的类型可以不加）
        invoCacl(1, 2, (int x, int y) -> {
            return x + y;
        });
    }
 
    public static void invoCacl(int x, int y, Calculator cacl) {
        int result = cacl.calc(x, y);
        System.out.println("结果是：" + result);
    }
}

基于Lamada表达式遍历

//遍历list 集合，用的for(String s:list)进行的
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.forEach(s -> System.out.println(s));
 
//遍历map，用的for(Map.Entry<K, V> entry:entrySet())进行的
Map<String, String> map = new HashMap<String, String>();
map.put("name1", "jack");
map.put("name2", "rose");
map.forEach((key, value) -> {
    System.out.println(key);
    System.out.println(value);
});