Java从入门到精通十四(Lambda表达式)

举报
兰舟千帆 发表于 2022/07/21 18:21:36 2022/07/21
【摘要】 @[TOC](Java从入门到精通十四(Lambda表达式)) Lambda的引入体验lambda是java8之后的一个新的特性。我当时学java的时候还没有见过这个表达式。主要是lambda简化了代码块,在某些方面,是比匿名内部类更加方便地。但是并不能完全替代匿名内部类。在使用地方面,还是有区别地,具体的,后面说。还记得自己创建线程吗?一种是自己去继承Thread然后实现run()方法。这...

@[TOC](Java从入门到精通十四(Lambda表达式))

Lambda的引入体验

lambda是java8之后的一个新的特性。我当时学java的时候还没有见过这个表达式。主要是lambda简化了代码块,在某些方面,是比匿名内部类更加方便地。但是并不能完全替代匿名内部类。在使用地方面,还是有区别地,具体的,后面说。
在这里插入图片描述
还记得自己创建线程吗?一种是自己去继承Thread然后实现run()方法。这是基本的,如果还需要自己再重写一些方法,也可以去实现。就像这样。

package demo.LambdaDemo;

public class LambdaDemo extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public LambdaDemo(String name) {
        super(name);
    }

    public LambdaDemo() {
        super();
    }

    public static void main(String[] args) {

        LambdaDemo ld = new LambdaDemo("线程1");
        LambdaDemo ld1 = new LambdaDemo("线程2");
        ld.start();
        ld1.start();


}

还可以去实现Runable接口
先定义一个类,实现Runable接口。

package demo.LambdaDemo;

public class MyRunnable implements Runnable {

    @Override
    public void run() {

    }
}

然后具体类似这样的格式

package demo.LambdaDemo;

public class MyRunnable implements Runnable {

    @Override
    public void run() {

    }

    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread th = new Thread(my);
        th.start();
    }
}

还有一种是采用匿名内部类

 new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("");
            }
        }).start();

这样简化了操作。但是lambda比这个还要简化。

  new Thread(() -> {

           System.out.println("...");
       }).start();

对比上面的说明格式,你应该注意到这种格式。lambda里面有一个(),括号里面要求的是一种形式参数,但是你可以注意到我们这里英勇的接口没有使用形式参数,所以可以省略掉,然后剩下的就是你想做的事情了。所以就是这样的格式。

在这里,我们先体验一下,然后下面展开说明一些基本的使用具体实例。

实例一(抽象方法无参无返回值)

首先定义一个接口

package demo.LambdaDemo;

public interface Eatable {
    void eat();
}

在测试类调用
我们可以去使用一个方法将接口参数传入

private static void  useEatable(Eatable e)
    {
        e.eat();
    }

然后你这样调用的话,其实还是没有具体实现。那么我们去具体实现一下。

采用匿名内部类

//匿名内部类实现
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("....");
            }
        });

对应采用的lambda表达式

  useEatable(()->{
            System.out.println("...");
        });

useEatable是我们定义的方法,我们的这个方法对应到接口Eatable接口,然后Eatable里面的这个方法并没有参数,我们就不需要传参,所以可以直接在{}里面做我们需要完成的事情。

实例二(抽线方法有参无返回值)

定义的接口类

package demo.LambdaDemo;

public interface Flayable {
    void fly(String s);

}

可以注意到这个接口中的方法是有参的
还是在测试类中写一个方法

private static void useFlyable(Flayable f)
    {
        f.fly("。。。。。。。");
    }

可以采用内名内部类对接口方法具体实现

   //匿名内部类
        useFlyable(new Flayable() {
            @Override
            public void fly(String s) {
                System.out.println(";;;;;;;;");
            }
        });

采用lambda表达式

  //lambda表达式
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println(".....");
        });

实例三(抽象方法带参带返回值)

比如这样

package demo.LambdaDemo;

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

这是一个带参带返回值的抽象方法

然后匿名内部类实现

useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return  x-y;
            }
        });

对的,这个方法具体实现在这里,具体的功能还是由我们自己具体实现来定。

lambda表达式

    useAddable((int x,int y)->{
            return  x+y;
        });

这是基本的写法。

lambda的表达式的简化操作

在特定条件下可以省略一些东西,变得更加简化。

1:参数类型可以省略(但是有多个参数的情况下,不能只省略一个)

如下,我们还是定义一个接口类

package demo.LambdaDemo.lambdaDemo01;

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

然后测试类定义一个方法,当然在这里你也可以去简单实现

 private static void useAddable(Addable a)
    {
        int sum = a.add(10,20);
        System.out.println(sum);
    }

lambda常规

 useAddable((int x,int y)->{
           return  x+y;
        });

lambda简化

useAddable((x,y)->{
            return x+y;
        });

注意这里省略的是参数类型,不是参数。

2:如果有且仅有一个参数,那么小括号可以省略

我们定义一个接口类

package demo.LambdaDemo.lambdaDemo01;

public interface Flyable {
    void fly(String s);
    
}


测试类定义方法

 private static void useFlyable(Flayable f)
    {
        f.fly("......");
    }
  private static void useAddable(Addable a)
    {
        int sum = a.add(10,20);
        System.out.println(sum);
    }

然后测试类操作
lambda常规


 useFlyable((String s)->{
            System.out.println("....");
        });

lambda简化


      useFlyable(s->{
            System.out.println("....");
        });

3:如果代码块的语句只有一条,可以省略大括号和分号,如果有return,return也要省略掉

useFlyable(s-> System.out.println("...."));

如果有return ,return也要省略掉

useAddable((x,y)->x+y);

完整测试代码
接口

package demo.LambdaDemo.lambdaDemo01;

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

package demo.LambdaDemo.lambdaDemo01;

public interface Flyable {
    void fly(String s);
}

测试类,部分代码已经注释。

package demo.LambdaDemo.lambdaDemo01;

import demo.LambdaDemo.Flayable;

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y)->{
//            return  x+y;
//        });
        //省略
//        //1:参数类型可以省略(但是有多个参数的情况下,不能只省略一个)
//        useAddable((x,y)->{
//            return x+y;
//        });
//        useFlyable((String s)->{
//            System.out.println("....");
//        });
//        useFlyable((s)->{
//            System.out.println("....");
//        });
        //2:如果有且仅有一个参数,那么小括号可以省略
//        useFlyable(s->{
//            System.out.println("....");
//        });
//        3:如果代码块的语句只有一条,可以省略大括号和分号,如果有return,return也要省略掉
//        useFlyable(s-> System.out.println("...."));
        //如果有return ,return也要省略掉
        useAddable((x,y)->x+y);

    }

    private static void useFlyable(Flayable f)
    {
        f.fly("......");
    }
    private static void useAddable(Addable a)
    {
        int sum = a.add(10,20);
        System.out.println(sum);
    }
}

匿名内部类和lambda的使用区别

在这里插入图片描述
在这里插入图片描述
lambda的使用是比较严格的,要求有接口,还必须只有一个抽象方法。并且lambda必须是只能实现接口。在用法上,必须要有上下文环境。
这就说明的是,lambda表达式虽然可以省略某些内容,但是你必须提供上下文化境,让lambda可以推导出你是使用了什么接口,接口中的参数是什么等等。

简单的说,就是如果你没有定义接口,你直接使用lambda是不行的。接口或者接口中的方法可以认为是可以提供的环境,这样,省略的时候可以推导出来,下文的环境,就是基本你去实现的具体过程。

匿名内部类的要求比较宽泛。因为它的类型是都可以的。抽象类,接口,具体类都可以。在原理上,就是匿名内部类会在执行后生成一个新的字节码文件,但是lambda并不会,lambda是动态生成的。
具体测试

package demo.LambdaDemo.lambdaDemo02.lambdaDemo03;

public interface Inter {
    void show();
}

package demo.LambdaDemo.lambdaDemo02.lambdaDemo03;

public class Student {
    public void study()
    {
        System.out.println("....");
    }
}

package demo.LambdaDemo.lambdaDemo02.lambdaDemo03;

public  abstract class Animal {
    public abstract void method();
}

package demo.LambdaDemo.lambdaDemo02.lambdaDemo03;

public class LambdaDemo {
    public static void main(String[] args) {
//        //使用内名内部类
//        useInter(new Inter() {
//            @Override
//            public void show() {
//                System.out.println("接口");//接口调用
//            }
//        });
//        useAnimal(new Animal() {
//            @Override
//            public void method() {
//                System.out.println("抽象类");
//            }
//        });//可以调用方法参数为抽象类的形式
//        useStudent(new Student(){
//            public  void study(){
//                System.out.println("具体类");
//            }
//        });//也可以是具体类
        //使用lambda只能是接口
        useInter(()-> System.out.println("接口"));
        //如果接口中有一个以上的抽象方法,那么就无法使用lambda表达式,只能用匿名内部类

    }

    private  static void useStudent(Student s)
    {
        s.study();
    }
    private static void useAnimal(Animal a)
    {
        a.method();
    }
    private static void useInter(Inter i)
    {
        i.show();
    }
}

基本的使用就是这些,具体的可以尝试使用了解。

我的主页

【版权声明】本文为华为云社区用户原创内容,未经允许不得转载,如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。