精华内容
下载资源
问答
  • 如何在Java中使用Lambda表达式实现Runnable接口?
    2021-04-17 05:21:04

    Runnable接口是java.lang包中定义的功能接口。 此接口包含单个抽象方法run(),不带参数。 当实现此接口的类的对象用于创建线程时,则run()方法已在单独执行的线程中调用。

    语法@FunctionalInterface

    public interface Runnable {

    void run();

    }

    在下面的示例中,我们可以使用匿名类和lambda表达式来实现Runnable接口。

    示例public class RunnableLambdaTest {

    public static void main(String[] args) {

    Runnable r1 = new Runnable() {

    @Override

    public void run() { // anonymous class

    System.out.println("Runnable with Anonymous Class");

    }

    };

    Runnable r2 = () -> {   // lambda expression

    System.out.println("Runnable with Lambda Expression");

    };

    new Thread(r1).start();

    new Thread(r2).start();

    }

    }

    输出结果Runnable with Anonymous ClassRunnable with Lambda Expression

    更多相关内容
  • 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表达式实现Runnable

    千次阅读 2020-04-29 16:49:27
    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();
    
    }
    展开全文
  • 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);
    }
    
    

    在这里插入图片描述

    展开全文
  • 2,而Thread类本身就是Runnable接口的实现类(代理对象)(设置目标对象为真实对象的类型) 3,把真实对象装入代理对象 Lambda注意: 1,前提是接口为函数式接口 2,lambda有一行代码的情况下,才能简化成一行,如果...
  • 请参阅ExecutorService的文档,其中包含两个提交方法和一个参数:你的lambda给出一个输出,返回一些东西:executorService.submit(() -> {System.out.println("Starting");int n = new Random().nextInt(4000);// ...
  • Java 8 Runnable和Callable使用Lambda表达式示例Java 8 Runnable ...我们可以使用lambda表达式实现run()和call()方法。 在此页面上,我们还将提供如何将参数传递给Runnable和Callable方法。 Java 8 Runnable Lambda
  • package create_thread; /** * @author LTH ...class MyThread2 implements Runnable { @Override public void run() { for (int i = 0; i < 100; i += 2) { System.out.println(i); } } } public
  • 匿名内部类 匿名内部类是没有显示名字的内部类,它继承一个类或实现一个接口。...以Runnable实现多线程为例: public class Demo5 { public static void main(String[] args) { new Thread(new Runnable() { ...
  • 1. 执行结果: ps:调用的是start方法而不是run方法,在图中可以看到,如果调用run方法,是先执行开辟线程再执行主线程,而start方法是重写开辟一条线程并由CPU调度执行顺序...2.实现多线程同步下载图片 ...
  • 1 为什么要用Runnable上一篇文章介绍了通过继承Thread类,实现java多线程。但如果当我们创建的这个线程类还想继承其他类的时候,这种方法就略显局限了。这也是java单继承的局限性。为了避免这种局限性,所以又提供了...
  • lambda表达式实现原理分析

    千次阅读 2021-12-12 10:33:14
    本文将深入了解lambda表达式的实现原理和这样的实现方案的取舍权衡。 Java为什么需要lambda表达式? 能够提升代码简洁性、提高代码可读性。 例如,在平时的开发过程中,把一个列表转换成另一个列表或map等等这样...
  • (2)创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。 (可以在创建Thread对象时为该Thread对象指定一个名字) (3)调用线程对象...
  • 16.2.2 实现Runnable接口创建线程类如何获取当前线程对象Runnable接口是函数式接口多个线程共享一个target则可以共享target中的实例变量document.querySelector(".post-body > ul").style.display="none"16.2.2 实现...
  • Runnable lambda

    千次阅读 2016-01-29 11:28:18
    // 1.1使用匿名内部类 new Thread(new Runnable() { @Override public void run() { System.out.println("Hello world !"); } }).start(); // 1.2使用 lambda expression new Thread
  • 实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里? 为什么说本质上只有一种实现线程的方式? 创建线程方式 例举6种: 线程主体类继承Runable接口,覆写run()方法,使用时将主体类的实例传到Thread类...
  • 基于Runnable接口实现多线程 虽然可以通过Thread类的继承来实现多线程的定义,但是在Java程序里面对于继承永远是存在单...范例:通过Runnable实现多线程的主体类 class MyThread implements Runnable{//线程的主体类
  • Java从入门到放弃26—线程的三种创建方式之实现Runnable接口 01 Runnable接口 Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。Runnable 为非 Thread 子类的...
  • 1、使用Lambda表达式实现多线程public static void main(String[] args) {//使用匿名内部类的方式,实现多线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread()....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,436
精华内容 11,374
关键字:

lambda实现runnable