java8型特性1- lambda表达式

一 lambda表达式

1.1 lambda语法介绍

lambda表达式本质上是一个匿名内部类函数。lambda表达式也常被称为闭包。

Lambda表达式 有参数、箭头和主体组成。在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “ ->”。该操作符被称为 Lambda 操作符或剪头操作符。
左侧：指定了Lambda表达式需要的所有参数 ；

右侧：指定了Lambda体，即lambda表达式要执行的功能。

结构：

(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

->：由英文中画线和大于符号组成，固定写法。代表指向动作

代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

组成Lambda表达式的三要素：

• 形式参数，箭头，代码块

1.2 使用前提

Lambda表达式的使用前提

• 有一个接口

• 接口中有且仅有一个抽象方法

1.3 各种案例

• 参数类型可以省略。但是有多个参数的情况下，不能只省略一个

• 如果参数有且仅有一个，那么小括号可以省略

• 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

    public static void main(String[] args) {
        //语法格式一：无参数，无返回值
        Runnable r1= () -> System.out.println("hello");
        r1.run();
       //语法格式二：有一个参数，并且无返回值
        Consumer<String> con2 = (x) -> System.out.println(x);
        con2.accept("welcome to beijing ！");
     // 语法格式三：若只有一个参数，小括号可以省略不写
        Consumer<String> con = x -> System.out.println(x);
        con.accept("welcome to beijing ！");
    // 语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
        Comparator<Integer> com = (x, y) -> {
 			System.out.println("函数式接口");
 			return Integer.compare(x, y);
 	};
        com.compare(3,4);
   //语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
        Comparator<Integer> com2 = (x, y) -> Integer.compare(x, y);
        com2.compare(3,4);
  //语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
        Comparator<Integer> com3 = (Integer x, Integer y) -> Integer.compare(x, y);
        int k=com3.compare(5,4);
        System.out.println("k:"+k);
    }

1.4 java8 匿名内部类与lamda表达式区别

1.所需类型不同

匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

Lambda表达式：只能是接口

2.使用限制不同

如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

3.实现原理不同

匿名内部类：编译之后，产生一个单独的.class字节码文件

Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成。

二 案例说明

2.1  Runable接口实现类

1.runable实现类

public class AnalyasiData implements  Runnable{
    @Override
    public void run() {
        System.out.println("我是实现类!!!");
    }
}

2.不同方式调用

package lamda.demo1;

/**
 * @ClassName: TestRun
 * @Description: TODO
 * @Author: liujianfu
 * @Date: 2022/11/05 17:54:31 
 * @Version: V1.0
 **/
public class TestRun {
    public static void main(String[] args) {
        //方式1：类.方法调用
        Runnable r=new AnalyasiData();
        new Thread(r).start();
        //方式2： 匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是匿名内部类 !!!");
            }
        }).start();
        //方式3: lamda表达式
       new Thread( ()->{System.out.println("我是lambda表达式!!!");}).start();
    }

}

2.2  无参无返回值

1.接口

public interface WuCan {
    public void sayHello();
}

2.实现类

public class WucanLei implements WuCan{
    @Override
    public void sayHello() {
        System.out.println("无参函数.....");
    }
}

3.调用测试

public class TestWucan {
    public static void main(String[] args) {
        //方式1 方法调用
        WuCan wc=new WucanLei();
        wc.sayHello();;
        //方式2： 匿名类调用
        WuCan w=new WuCan() {
            @Override
            public void sayHello() {
                System.out.println("匿名类调用");
            }
        };
        w.sayHello();
        //方式3 lamda
        WuCan wc2=()->{System.out.println("lamda表达式");};
        wc2.sayHello();
    }

}

2.3  无参有返回值

1.接口

public interface Youcan {
    public void  say(String info);
}

2.实现类

public class YouCanLei implements Youcan{
    @Override
    public void say(String info) {
        System.out.println("我是:"+info);
    }
}

3.测试类

public class TestYoucan {
    public static void main(String[] args) {
        //方式1
        Youcan youcan=new YouCanLei();
        youcan.say("方式调用");
        //方式2
        Youcan yc=new Youcan() {
            @Override
            public void say(String info) {
                System.out.println("我是:"+info);
            }
        };
        yc.say("匿名类调用");
        //方式3
        Youcan ycc=(x)->{System.out.println("我是:"+x);};
        ycc.say("lamdad调用！");

    }
}

2.4  有参有返回值

1.接口

public interface YouCanAndWuCan {
    public Integer add(int x,int y);
}

2.实现类

public class QiuHe implements YouCanAndWuCan {
    @Override
    public Integer add(int x, int y) {
        return x+y;
    }
}

3.测试

public class TestQiu {
    public static void main(String[] args) {
        //方式1
        YouCanAndWuCan youCanAndWuCan=new QiuHe();
        int k=youCanAndWuCan.add(3,4);
        System.out.println("k:"+k);
        //方式2
       int m= new YouCanAndWuCan(){
           @Override
       public Integer add(int x, int y) {
           return x+y;
       }}.add(3,4);
       System.out.println("m:"+m);
       //方式3
        YouCanAndWuCan youCanAndWuCan1=(int x,int y)->{return x+y;};
       int n= youCanAndWuCan.add(3,4);
       System.out.println("n:"+n);
    }
}