Java 8 Lambda 表达式

目录

出现的背景

外部类

代码

运行

内部类

代码

运行

匿名内部类

代码

运行

Lambda 表达式简介

Lambda 表达式的结构

lambda表达式

代码

运行

什么是功能接口（Functional interface）

代码

接口

实现类

使用方法重写

使用lambda表达式

运行

---

出现的背景

匿名函数  为了简化Java中的匿名内部类

事件监听 写一个类实现 ActionListener 接口（外部类）

\|/

内部类  类在其他地方用不到，索性就把这个类定义在类的内部使用

             好处：1.内部可以使用外部类的成员

                        2.其他地方发现不了

\|/

往往内部类至使用一次，还要创建一个内部类，麻烦

Java为了简化语法，new 接口/抽象类  创建了一个匿名的类的对象

外部类

代码

package com.ffyc.demo;

import java.util.ArrayList;

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

        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("a");

        //排序,定义排序规则
        arrayList.sort(new StringComparator());
        System.out.println(arrayList);
    }
}

package com.ffyc.demo;

import java.util.Comparator;

public class StringComparator implements Comparator<String> {
    public static void main(String[] args) {

    }

    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
}

运行

内部类

代码

package com.ffyc.demo;

import java.util.ArrayList;
import java.util.Comparator;

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

        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("a");

        //排序,定义排序规则
        arrayList.sort(new StringComparator());
        System.out.println(arrayList);
    }
    /*
      内部类来实现接口
    */
    static class StringComparator implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    }
}

运行

匿名内部类

代码

package com.ffyc.demo;

import java.util.ArrayList;
import java.util.Comparator;

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

        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("a");

        //排序,定义排序规则 

        //匿名内部类，为了减少类的创建
        //此处功能核心是compareTo方法，但是Java是面向对象的，方法的不能独立存在的，必须将方法包装在对象中
        arrayList.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        System.out.println(arrayList);
    }
}

运行

Java8之前，函数/方法是不能当作参数传递的，必须将函数包装在对象中。

但是核心就是函数完成某个功能而已，还需要创建一个对象，成本高。

Java8开始，对这一语法进行了简化，匿名内部类都不需要创建了，直接将函数作为参数传递了。

Lambda 表达式简介

lambda 是匿名函数，把函数当作参数一样传递

lambda是一个“语法糖”，就是一个名词，某种语法可以简化开发称为语法糖

装箱  拆箱

自动类型转换

泛型

Lambda 表达式的结构

(参数列表)->{函数体}
()->{
            
}     

lambda表达式

代码

package com.ffyc.demo;

import javax.swing.*;
import java.util.ArrayList;
import java.util.Comparator;

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

        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("a");

        //排序,定义排序规则
        arrayList.sort((a,b)->{

            return a.compareTo(b);
        });

        System.out.println(arrayList);

        new JButton().addActionListener((e)->{
            System.out.println(e.getWhen());
        }); 
    } 
}

运行

什么是功能接口（Functional interface）

Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能 接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽 象方法接口。Java 8 也引入了一个注释，即@FunctionalInterface，当你注释 的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

代码

接口

package com.ffyc.demo;

//使用lambda表达式 也是有要求的，一个接口中只能有一抽象方法
//为什么？因为函数是匿名的，全靠语法的推断
@FunctionalInterface
//添加@FunctionalInterface注解的接口中，只能有一个抽象方法
public interface Computer {
    int add(int a,int b);

    //int sub(int a,int b);
}

当接口中定义了两个方法时，@FunctionalInterface会检测语法错误，会报错。

实现类

使用方法重写

package com.ffyc.demo;

public class Demo2 {

    static class comImpl implements Computer{

        @Override
        public int add(int a, int b) {
            return a+b;
        }
    }
    public void test(Computer computer){
        int res = computer.add(10, 20);
        System.out.println(res);
    }

    public static void main(String[] args) { 
        new Demo2().test(new comImpl()); 
    }
}

使用lambda表达式

package com.ffyc.demo;

public class Demo2 { 
    public void test(Computer computer){
        int res = computer.add(10, 20);
        System.out.println(res);
    }

    public static void main(String[] args) {
        //底层会将匿名对象包装到一个对象中，
        new Demo2().test((a,b)->{
            return a+b;
        }); 

        new Thread(()->{
            System.out.println("使用lambda创建了一个线程，并重写了run方法");
        }).start();
    }
}

运行