精华内容
下载资源
问答
  • lambda表达式实现Runnable lambda表达式替换了原来匿名内部类的写法,没有了匿名内部类繁杂的代码实现,而是突出了,真正的处理代码。最好的示例就是 实现Runnable 的线程实现方式了: 用() -> {}代码块替代了...

    用lambda表达式实现Runnable

    lambda表达式替换了原来匿名内部类的写法,没有了匿名内部类繁杂的代码实现,而是突出了,真正的处理代码。最好的示例就是 实现Runnable 的线程实现方式了: 用() -> {}代码块替代了整个匿名内部类

     

    @Test
    public void test() {
        //old
        new Thread((new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类 实现线程");
            }
        })).start();
        //lambda
        new Thread(() -> System.out.println("java8 lambda实现线程")).start();
    
    }
    展开全文
  • java8新特性:lambda表达式,使用lambda表达式实现Runnable接口 1.使用lambda表达式实现interface接口 1.1、当一个接口只有一个方法时,可以使用lambda表达式实现这个接口。 1.2、当方法中只有一条语句时,可以不写大...

    java8新特性:lambda表达式,使用lambda表达式实现Runnable接口

    1.使用lambda表达式实现interface接口

    1.1、当一个接口只有一个方法时,可以使用lambda表达式实现这个接口。
    1.2、当方法中只有一条语句时,可以不写大括号
    1.3、方法中超过一条语句时,需要写大括号

    interface Animal{
    	void play();
    }
    Animal animal = ()->{System.out.print("hello");}//当一个接口只有一个方法时,可以使用lambda表达式实现这个接口。
    
    
    Animal animal2 = ()-> System.out.println();//当只有一条语句时,可以不写大括号
    Animal animal3 = ()->{
    	int count = 1 + 1;
    	System.out.print(count);
    }
    

    2.使用lambda表达式实现Runnable接口

    Runnable runnable = ()->{
                System.out.println("hello");
            };//这里的()实现的是run()方法
    

    3.使用lambda表达式启动一个Thread线程

    不用lambda表达式的实现:

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

    使用lambda表达式的实现:

    new Thread(()->{
                System.out.println("hello");
            }).start();
    

    这里为什么可以只写()->{}表示Runnable?因为Thread的构造方法中需要放一个Runnable类型的参数,然而()->{}这个lambda表达式就代表了一个Runnable,将它们拆分开就是下面这种写法:

    Runnable runnable = ()->{
                System.out.println("hello");
            };
    
    new Thread(runnable).start;
    

    所以我们可以将它们合在一起写,于是就变成了:

    new Thread(()->{
                System.out.println("hello");
            }).start();
    

    ############# 跑题了,回到主题。########

    4.当一个方法只有return语句时,可以省略大括号和return

    interface Animal{
        String say();
    }
    
    Animal animal = ()->"hello";
    

    5.当方法只有一个参数时,可以省略括号,不需要写参数修饰符(注意,这里指可以省略参数的小括号)

    interface Animal{
        void say(String voice);
    }
    Animal animal = voice -> System.out.println(voice);
    

    6.方法有参数个数超过一个,不能省略小括号

    interface Animal{
        void say(String voice,int num);
    }
    Animal animal = (voice,num) -> System.out.println(voice+"-->"+num);
    
    展开全文
  • Lambda 表达式(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。Lambda表达式可以表示闭包...

    1. Lamda表达式

    Lambda 表达式(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。Lambda表达式可以表示闭包(注意和数学传统意义上的不同)。

    Java 8的一个大亮点是引入Lambda表达式,使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时,也会随之被编译成一个函数式接口。下面这个例子就是使用Lambda语法来代替匿名的内部类,代码不仅简洁,而且还可读。

    函数式接口的定义:

    • 任何接口,如果质保函唯一一个抽象方法,那么它就是一个函数式接口
      public interface Runnable{
      public abstract void run();
      }
    • 对于函数式接口,我们可以通过lambda表达式来创建改接口的对象
    package com.ren.lambdaShow;
    
    /**
     * @author Ren
     */
    
    /**
     * 推导lambda表达式
     */
    public class TestLambda01 {
    
        //3. 静态内部类
        static class Like2 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("I like lambda2");
            }
        }
    
        public static void main(String[] args) {
            Ilike like = new Like1();
            like.lambda();
    
            like = new Like2();
            like.lambda();
    
    
            //4. 局部内部类
            class Like3 implements Ilike {
                @Override
                public void lambda() {
                    System.out.println("I like lambda3");
                }
            }
    
            like = new Like3();
            like.lambda();
    
    
            //5. 匿名内部类
            like = new Ilike() {
                @Override
                public void lambda() {
                    System.out.println("I like lambda4");
                }
            };
            like.lambda();
    
    
            //6. 用lambda表达式简化
            like = ()->{
                System.out.println("I like lambda5");
            };
            like.lambda();
        }
    }
    
    //1. 定义一个函数式接口
    
    interface Ilike {
        void lambda();
    }
    
    //2. 实现类
    
    class Like1 implements Ilike {
    
        @Override
        public void lambda() {
            System.out.println("I like lambda1");
        }
    }
    

    在这里插入图片描述

    package com.ren.lambdaShow;
    
    /**
     * @author Ren
     */
    
    public class TestLambda02 {
    
        public static void main(String[] args) {
            Ilove love = null;
    
            love = (int a)->{
                System.out.println("I love you -> " + a);
            };
            love.love(520);
    
            //简化1: lambda表达式简化 去掉参数类型
            love = (a)->{
                System.out.println("I love you -> " + a);
            };
            love.love(521);
    
            //简化2: 去掉括号
            love = a->{
                System.out.println("I love you -> " + a);
            };
            love.love(5201);
    
            //简化3: 去掉花括号
            love = a-> System.out.println("I love you -> " + a);
            love.love(555521);
    
            /**
             * 总结:
             *      lambda表达式只能在只有一行才能简化成一行,如果有多行,那么就用代码块包裹
             *      前提是: 接口是函数式接口(一个借口中只能有一个方法)
             *      多个参数,也可以去掉参数类型,要去的就都去了,必须加上括号(a,b,c)
             */
    
        }
    }
    
    interface Ilove{
        void love(int a);
    }
    
    

    在这里插入图片描述

    展开全文
  • 1、使用Lambda表达式实现多线程public static void main(String[] args) {//使用匿名内部类的方式,实现多线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread()....

    1、使用Lambda表达式实现多线程

    public static void main(String[] args) {

    //使用匿名内部类的方式,实现多线程

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(Thread.currentThread().getName() + "新线程创建了!");

    }

    }).start();

    //使用Lambda表达式,实现多线程

    new Thread(() -> {

    System.out.println(Thread.currentThread().getName() + "新线程创建了!");

    }

    ).start();

    }

    2、Lambda表达式的标准格式

    (参数列表,用逗号隔开)-> {一些重写方法的代码};

    3、Lambda的作用和目的:

    简化匿名内部类的书写。

    4、Lambda表达式继续省略(凡是根据上下文可以推导出来的内容,都可以省略):

    a、(参数列表):括号中的参数列表的数据类型,可以省略不写;

    b、(参数列表):括号中的参数如果只有一个,那么数据类型和小括号( )都可以省略;

    c、{一些代码}:如果大括号{ }中的代码只有一行,就可以省略大括号{ },return和分号

    注意:要省略必须三个一起省略。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 文章目录 多线程 一、线程与进程 二、线程调度 三、同步与异步&并发与并行 四、多线程实现方式 1、继承Thread 2、实现Runnable 3、实现Runnable和继承Thread比较 4、匿名内部类实现方式 五、Thread类 六、设置和获取...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 665
精华内容 266
关键字:

lambda实现runnable