java8新特性-Lambda表达式

Lambda表达式

只要会匿名内部类， 一定会Lambda表达式

Runnable使用Lambda

public class LamadaTest {

    public static void main(String[] args) {

        // 强调: 怎么做-------------------------------------
        // 面向对象不好的地方:
        // 1. 不得不创建一个类, 实现Runnable接口
        // 2. 如果不想创建类, 不得不使用匿名内部类
        // 3. 使用匿名内部类, 不得不重写run方法
        // 4. 重写run方法, 不得不写出跟父类一样的, 返回值类型, 方法名,参数列表
        // 5. 最后才要写出run方法里面的代码
        new Thread(new Runnable() {

            @Override
            public void run() {

                System.out.println("使用匿名内部类创建一个线程1");
            }
        }).start();
        
        // 开启一条新线程  ->  开启线程, 让run方法中的代码执行起来

        // 目标: 线程  run里面的代码跑起来

        // 我们要做的就剩  指定run方法里面的代码
        
        // 函数式编程: 强调: 做什么
        new Thread(() -> System.out.println("开启了一条新线程2")).start();
        new Thread(() -> System.out.println("开启了一条新线程3")).start();
        new Thread(() -> System.out.println("开启了一条新线程4")).start();
        new Thread(() -> System.out.println("开启了一条新线程5")).start();
        new Thread(() -> System.out.println("开启了一条新线程6")).start();
        new Thread(() -> System.out.println("开启了一条新线程7")).start();

    }
}

Lambda表达式的格式和前提

格式

() -> {}
() : 参数列表(一些参数)
-> : 一个箭头 将小括号中的参数, 给大括号中使用
{} : 一段代码
    
    
Lambda表达式其实是对匿名内部类的改写
() : 匿名内部类中重写方法的参数列表
{} : 匿名内部类中重写方法的方法体

前提

1. 使用的接口, 一定是一个函数式接口(有且只有一个抽象方法的接口)@FunctionalInterface
2. 函数式接口要作为方法的参数（主要使用场景）或者返回。

1. 无参无返回的Lambda

package com.free._03lambda.demo02;

@FunctionalInterface
public interface MyInter2 {
    void fun();
}

package com.free._03lambda.demo02;

/*

    无参无返回的Lambda

        模拟: 函数式接口
             函数式接口作为参数的方法

        关注: 方法的调用
 */
public class Demo02 {
    public static void main(String[] args) {
        // 方法的调用
        print(new MyInter2() {
            @Override
            public void fun() {
                System.out.println("无参无返回的匿名内部类");
            }
        });


        // Lambda
        print(() -> System.out.println("无参无返回的Lambda"));

    }

    // 函数式接口作为参数的方法
    public static void print(MyInter2 lambda) { // 传入的一定是实现类对象
        lambda.fun();
    }

}

2. 有参无返回的Lambda

package com.free._03lambda.demo03;

public interface MyInter3 {
    String fun();
}

package com.free._03lambda.demo03;
/*
    无参有返回
 */
public class Demo03 {
    public static void main(String[] args) {
        // 方法的调用
        print(new MyInter3() {
            @Override
            public String fun() {
                return "匿名内部类";
            }
        });

        // lambda
        print(() -> "Lambda");
    }


    public static void print(MyInter3 lambda) {
        String s = lambda.fun();
        System.out.println(s);
    }
}

3. 无参有返回的Lambda

package com.free._03lambda.demo04;

public interface MyInter4 {
    void fun(int i);
}

package com.free._03lambda.demo04;
/*
    有参无返回
 */
public class Demo04 {
    public static void main(String[] args) {

        print(new MyInter4() {
            @Override
            public void fun(int i) {
                System.out.println("匿名内部类不" + i);
            }
        });

        // lambda
        print(i -> System.out.println("Lambda" + i));

    }

    public static void print(MyInter4 lambda) {
        lambda.fun(666);
    }
}

4. 有参有返回的Lambda

package com.free._03lambda.demo05;

public interface MyInter5 {
    int stringToInt(String s);
}

package com.free._03lambda.demo05;
/*
    有参有返回
 */
public class Demo05 {
    public static void main(String[] args) {
        // 匿名内部类
        print(new MyInter5() {
            @Override
            public int stringToInt(String s) {
                // Integer.parseInt(字符串) -> 将数字格式的字符串转换成int类型的数字
                return Integer.parseInt(s);
            }
        });

        // lambda
        print(s -> Integer.parseInt(s));

        // Method Reference
        // print(Integer::parseInt);

    }

    public static void print(MyInter5 lambda) {
        int i = lambda.stringToInt("100");
        System.out.println(i);
    }
}

Comparator使用Lambda

package com.free._03lambda.demo06;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Demo06 {
    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();
        // 添加元素
        Collections.addAll(list, 5, 4, 2, 6, 8, 7, 9, 3, 1);

        // 降叙排序
        /*Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });*/

        // lambda
        Collections.sort(list, (o1, o2) -> o2 - o1);

        System.out.println(list);


        // 只有引用数据类型的数组, 才能使用比较器排序
        Integer[] arr = {2, 4, 3, 5, 1};
        /*Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });*/

        Arrays.sort(arr, (o1, o2) -> o2 - o1 );



        System.out.println(Arrays.toString(arr));

    }
}

Lambda的简化格式

原则: 可推导, 可省略.

1. 小括号中, 数据类型可以省略
2. 小括号中, 如果只有一个参数, 小括号可以省略
3. 大括号中, 如果只有一条语句, 可以省略大括号和分号
4. 大括号中, 如果只有一条语句且是返回语句，可省略return

alt+enter 自动转换成lamada表达式设置