Java8 新特性Lambda表达式-CSDN博客

本文链接：https://blog.csdn.net/ezconn/article/details/108197389

Java8型特性

1，Java8 新特性Lambda表达式

2，Java8 新特性新增的函数式接口

3，Java8 新特性方法引用和构造器引用

Java8 新特性Lambda表达式

简介

1，Lambda 表达式，也可称为闭包，是Java 8 中新加入的最重要新特性。

2，Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中，是面向函数式编程的思想）。

3，使用 Lambda 表达式可以使代码变的更加简洁紧凑。

4，用(参数列表) -> {执行语句} 就可以代替整个匿名内部类，参数列表其实就是接口中待实现的方法参数；

语法格式

(参数...) -> {执行语句}

主要分为三部分：

1，左侧：Lambda表达式的参数列表

2，中间：“->” Java8引入的一个新操作符，该操作符称为箭头操作符或者Lambda操作符

3，右侧：Lambda 表达式所需要执行的功能或语句，即 Lambda体；

语法的具体几种形式：

1，无参数，无返回值

() -> 执行语句

案例

Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"Java8 Lambda 表达式");
            }
        });

//Lambda实现以上匿名内部类部分
Thread thread2 = new Thread(() -> Log.d(TAG,"Java8 Lambda 表达式"));

说明：Lambda表达式:() -> Log.d(TAG,"Java8 Lambda 表达式")，就是对接口中run()抽象方法的实现；右侧Lambda体，只有一条语句时，{}省略不写；

2，有一个参数，没返回值

Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("哈喽");
            }
        };
//Lambda实现以上匿名内部类部分
Consumer<String> consumer1 = (s) -> System.out.println("哈喽");

3，只有一个参数时，()小括号可以省略

Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("哈喽");
            }
        };
//Lambda实现以上匿名内部类部分
Consumer<String> consumer1 = s -> System.out.println("哈喽");

4，有两个以上参数，有返回值，且只有一条执行语句；

(x,y) -> 一行执行语句

案例

TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

//Lambda实现以上匿名内部类部分
TreeSet<Integer> treeSet1 = new TreeSet<Integer>((o1, o2) -> o1.compareTo(o2));

说明：左侧有多个参数()不能省略；右侧只有一条语句，return和{}都可以省略不写；但是Lambda体如果加上{}，那么return也上加上，如下：

TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

TreeSet<Integer> treeSet1 = new TreeSet<Integer>((o1, o2) -> {
      return o1.compareTo(o2);
});

5，有参数，有返回值，且有多条执行语句；

(x,y) ->{多条语句}

案例

TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
         @Override
         public int compare(Integer o1, Integer o2) {
             return o1.compareTo(o2);
         }
});

TreeSet<Integer> treeSet1 = new TreeSet<Integer>((o1, o2) -> {
        System.out.println("多条语句执行");
        return o1.compareTo(o2);
});

说明：多条语句要用{}包裹起来，并且每条语句要加上"；"

6，参数列表的数据类型可以不写如：(o1, o2) -> o1.compareTo(o2);

如果加上：(Integer o1,Integer o2) ->o1.compareTo(o2);

使用条件

使用Lambda表达是的条件是：必须有函数式接口的支持；

函数式接口：接口中只有一个抽象方法时，但是可以有多个非抽象方法；可以使用注解@FunctionalInterface修饰，这样可以检查是否是函数接口；

Lambda应用

自定义Student类，

public class Student {
    private int id;
    private int age;
    private String name;
    private int score;

    public Student(int id, int age, String name, int score) {
        this.id = id;
        this.age = age;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

1，按年龄排序，年龄相同的按总成绩排序

List<Student> students = Arrays.asList(new Student(10,12,"张三",88)
        ,new Student(12,13,"赵四",58)
        ,new Student(14,15,"王五",78)
        ,new Student(11,18,"李六",99));

Collections.sort(students,(x,y) -> {
      if (x.getAge() == y.getAge()) {
           return Integer.compare(x.getScore(), y.getScore());
      }else {
           return Integer.compare(x.getAge(), y.getAge());
      }
});

for (Student s:students) {
     System.out.println(s);
}

运行结果：

Student{id=10, age=12, name='张三', score=88}
Student{id=12, age=13, name='赵四', score=58}
Student{id=14, age=15, name='王五', score=78}
Student{id=11, age=18, name='李六', score=99}

函数式接口可以自定义也可以使用Java8系统提供；一般不要自定义，使用系统提供的即可；