Java8新特性之--Lambda

Java8新特性之–Lambda

1 什么是Lambda？

Lambda就是一个匿名函数，使用Lambda表达式可以对一个接口进行简洁的实现。

2 Lambda对接口的要求

虽然可以使用Lambda表达式对某些接口进行简单的实现，但是并不是所有的接口都可用Lambda来实现；要求接口中定义的必须要实现的抽象方法只能是一个。

@FunctionalInterface

修饰函数接口的，接口中的抽象方法只有一个。

3 基础语法：

()：描述参数列表

{}：描述方法体

参数列表方法体之间用 “->” 分割，读作goes to；

形式：() -> {};

4 语法精简

1、参数类型精简

由于在接口的抽象方法中，已经定义了接口的数量和类型，所以在lambda表达式中参数的类型可以省略

接口定义:
@FunctionalInterface
public interface LambdaNoneReturnMultipleParameter {
    void test(int a, int b);
} 
    
接口实现:
精简前：
    LambdaNoneReturnMultipleParameter lambda1 = (int a, int b) -> {
		System.out.println("hello");
	};
精简后：
	LambdaNoneReturnMultipleParameter lambda1 = (a, b) -> {
		System.out.println("hello");
	};

2、参数括号精简

如果接口的参数只有一个，那么在lambda表达式中可以省略参数的类型和小括号

@FunctionalInterface
public interface LambdaNoneReturnSingleParameter {
    void test(int n);
}

接口实现：
精简前：
    LambdaNoneReturnSingleParameter lambda2 = (int a) -> {
            System.out.println("hello");
        };
精简后：
    LambdaNoneReturnSingleParameter lambda2 = a -> {
            System.out.println("hello");
        };

3、方法大括号精简

如果方法体只有一条语句，那么此时大括号可以省略

LambdaNoneReturnSingleParameter lambda2 = a -> System.out.println("hello");

4、return省略

如果方法体只有一条return语句，那么大括号和return必须同时省略。

精简前：
LambdaSingleReturnNoneParameter lambda2 = a -> {
    return 10;
}; 
精简后：
LambdaSingleReturnNoneParameter lambda2 = a -> 10;

5 引用

5.1 静态方法引用

public class Syntax3 {
    public static void main(String[] args) {
        //方法引用
        //可以快速的将一个lambda表达式指向一个已经实现的方法
        //语法实现方式：方法的隶属者::方法名  例如：Systax3::change
        //注意：参数的数量、类型、，返回值的类型保持一致
        LambdaSingleReturnSingleParameter lambda1 = a ->  a * 2 ;
        //等同于：
        LambdaSingleReturnSingleParameter lambda2 = a -> change(a) ;
        //等同于：
        LambdaSingleReturnSingleParameter lambda3 = Syntax3::change;

    }
    private static int change(int a){
        return a * 2;
    }
}

5.2 构造方法的引用

对象实体：
public class Person {
    public String name;
    public int age;

    public Person() {
        System.out.println("无参构造方法执行啦！");
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造方法执行啦！");
    }
}
方法：
public class syntax4 {
    public static void main(String[] args) {
        //构造函数的引用
        //无参
        PersonCreator creator2 = Person::new;
        Person p = creator2.getPerson();
        //有参
        PersonCreator2 creator3 = Person::new;
        Person p2 = creator3.getPerson("tom",10);
    }
}
interface PersonCreator{
    Person getPerson();
}
interface PersonCreator2{
    Person getPerson(String name, int age );
}

6、集合排序

6.1 List集合

public class ceshi1 {
    //集合排序
    public static void main(String[] args) {
        //需求：在一个list中有若干个Person对象，将这些Person对象按照年龄降序排列

        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("tom",20));
        list.add(new Person("jerry",10));
        list.add(new Person("mary",15));

        list.sort((a,b) ->  b.age-a.age );
        System.out.println(list);
    }
}
输出：
Person{name='tom', age=20}, Person{name='mary', age=15}, Person{name='jerry', age=10}

6.2 TreeSet集合

public class ceshi2 {
    public static void main(String[] args) {
        //TreeSet
        //使用lambda表达式实现Comparator接口，并实例化一个TreeSet对象
		//如果直接使用lambda表达式，set集合中如果存在相同元素，那么在遍历集合时，set会将b.age-a.age=0的情况视为相同的元素并去重
        TreeSet<Person> treeSet = new TreeSet<>((a,b) -> b.age-a.age);
        //所以需要将lambda表达式进行处理，判断b.age-a.age=0的时候不要返回0
        TreeSet<Person> treeSet = new TreeSet<>( (a,b) -> {
            if(a.age >= b.age){
                return -1;
            } else {
                return 1;
            }
        });

        treeSet.add(new Person("tom",20));
        treeSet.add(new Person("jerry",10));
        treeSet.add(new Person("mary",15));
        treeSet.add(new Person("mary1",10));

        System.out.println(treeSet);
        //[Person{name='tom', age=20}, Person{name='mary', age=15}, Person{name='jerry', age=10}]：少了一条数据
        //如果TreeSet集合有相同的值，Comparator的返回值是0，那么就会认为这两个元素是相同的，就要进行去重
    }
}

6.3 集合遍历–foreach

public class ceshi3 {
    public static void main(String[] args) {
        //集合遍历
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,0);
        //将集合的每一个元素都带入到accept方法中
        //list.forEach(System.out::println);

        //输出集合中的所有偶数
        list.forEach(ele -> {
            if(ele % 2 == 0)
                System.out.println(ele);
        });
    }
}