精华内容
下载资源
问答
  • Lambda表达式的作用:...Lambda表达式的使用前提:1、用Lambda表达式简化的这个匿名内部类必须是某一个接口的实现类,且这个实现的接口有且只有一个抽象方法;因为只有这样,Lambda才能够根据接口的上下文(代...

    Lambda表达式的作用:

    Lambda表达式的作用就是简化代码开发,让代码看起来更加简介。它是用来简化匿名内部类的。但是并不是所有的匿名内部类都能用Lambda表达式简化,Lambda表达式是有使用前提的。

    Lambda表达式的使用前提:

    1、用Lambda表达式简化的这个匿名内部类必须是某一个接口的实现类,且这个实现的接口中有且只有一个抽象方法;因为只有这样,Lambda才能够根据接口中的上下文(代码)来推断出你简化的地方是什么内容,下面就来实际演示一下。(注:有且只有一个抽象方法的接口称为“函数式接口”)

    2、使用Lambda表达式的地方必须具有上下文推断,就是在使用Lambda表达式的地方知道能够通过代码上下文推断出所需要的信息,因为Lambda表达式简化匿名内部类是不会写出匿名内部类实现所实现的接口,所以需要在能够推测出接口的地方使用(有点抽象,可以通过下面的案例来理解)。

    Lambda表达式的格式:

    Lambda表达式主要由三部分构成:()->{ }

    1、开头小括号开始 ( ) :小括号中填写的是重写接口中的方法时,方法的参数。若方法无参数,则小括号空着,若有多个参数,则参数间用逗号隔开(与普通Java方法相同)

    2、中间一个箭头 ->:可以理解为将参数传入到方法体中;

    3、末尾一个大括号{ }:大括号中的内容就是方法体,也就是方法的逻辑代码;

    当然,上面的结构是标准结构,但却不是绝对的,在某些情况下,部分内容可以省略,在下面的案例中将进行详细讲解。

    Lambda使用案例:

    案例一:Lambda表达式简化匿名内部类,重写无参数无返回值方法

    首先,我们创建一个接口,用来测试Lambda表达式。通过Lambda表达式的使用前提可知,这个接口应当有且只有一个抽象方法。接口名字叫Test,方法叫display():

    1 public interfaceTest {2

    3 public abstract voiddisplay();4

    5 }

    然后,我们创建一个类,这个类中有一个方法useDisplay(Test t),它唯一的参数就是上面定义的接口Test。我们知道,当要调用这个方法时,应当传入一个Test接口的实现类,方法代码如下:

    1 public static voiduseDisplay(Test t) {2 //方法的内容就是调用接口中的display方法

    3 t.display();4 }

    接下来,我们调用这个方法,分别采用匿名内部类以及Lambda表达式两种方式,以此来进行对比:

    1 //调用方法,接口参数使用匿名内部类当场实现

    2 useDisplay(3 newTest() {4 //重写接口中的方法,输出一句话

    5 @Override6 public voiddisplay() {7 System.out.println("Lambda表达式案例一");8 }9 }10 );

    上面的代码调用了useDisplay(Test t)方法,并在括号中使用匿名内部类实现了Test接口以及重写了Test的方法,将匿名内部类作为参数传递。这是匿名内部类的方式,那下面看看Lambda表达式时怎么去写的:

    1 useDisplay(2 //使用Lambda实现

    3 ()->{4 System.out.println("Lambda表达式案例一");5 }6 );

    可以看到,代码明显精简了许多,我们来仔细看看究竟做了哪些改变:我们省略new,也省略了接口的名字,直接重写接口中的方法。为什么可以这么做呢,这就关系到我们之前所说的Lambda使用前提2:使用Lambda表达式的地方必须具有上下文推断;Lambda知道useDisplay的参数是Test接口,所有Lambda知道这里应该实现的接口就是Test,不可能是其他的了,因此可以省略接口名。接下来省略了方法的public、返回值类型、方法名,这些Lambda也可以推断出来,因为已经确定了是Test接口,那自然也知道了这个接口中的方法display()的信息,所以统统可以省略,这也是Lambda表达式使用前提1的原因。

    然而,上面的Lambda表达式只是标准格式,它还能够继续简化,上面的表达式简化后的如下:

    1 useDisplay( ()->System.out.println("Lambda表达式案例一") /*此处原本有分号*/ );

    可以看到,上面的Lambda表达式相对于之前,省略了大括号以及末尾的分号。只有在Lambda表达式的方法体,也就是大括号中只有一条语句时,才能够省略大括号,同时也要省略分号,两者要么一起省略,要么都不省略。

    案例二:Lambda表达式简化匿名内部类,重写有参有返回值方法

    同样是定义一个接口Calculator,里面只有一个抽象方法add(),计算两个整数的和:

    1 public interfaceCalculator {2

    3 public abstract int add(int a,intb);4

    5 }

    与上一个案例类似的结构,在另一个类中定义一个方法invokeAdd,方法的内容就是调用接口中的add方法,得到两个整数的和并输出:

    1 public static void invokeAdd(int a,intb,Calculator cal) {2 System.out.println(cal.add(a, b));3 }

    首先还是和第一个案例一样,我们使用匿名内部类的方式调用这个方法(这次我把代码写的紧凑一些,上一个案例代码都拉的很开,方便查看):

    1 invokeAdd(10, 20, newCalculator() {2 @Override3 public int add(int a, intb) {4 return a+b;5 }6 });

    上面代码很简单,传入两个要相加的整数10和20,以及一个匿名内部类对象实现,实现Calculator接口,重写接口中add方法,求两个整数的和。下面来看看Lambda表达式怎么写上面这个代码:

    1 //使用Lambda表达式的方式代替匿名内部类实现

    2 invokeAdd(10, 20, (int a,int b)->{3 return a+b;4 });

    还是来看看改变了哪些内容:首先,这是比较标准的写法,与案例一相同,省略了接口,直接重写接口中的方法,然后省略了方法的名字类型等,只留下一个大括号,里面包含方法的参数,后面跟着一个箭头,指向了方法体,而方法体则未改变。但是,这并不是最简略的写法,看下面这种更加简洁的写法:

    1 //上Lambda表达式的简化

    2 invokeAdd(10, 20, (a,b) -> a+b );

    可以看到,这时已经简化到只剩一句代码了,我们来仔细看看简化了哪些内容:首先,填写方法参数的小括号中,参数的类型省略了,还是和上面一样的原因,既然Lambda表达式已经知道了你实现的接口,就知道了接口中那唯一的方法,也就知道了方法中参数的类型,所以即使你省略,Lambda也能够根据上下文推测出来;其次,因为方法体中只有一句代码,所以可以省略大括号以及方法体中语句末尾的分号;除此之外,这是一个有返回值的方法,在方法体中只有一句代码的情况下,连return这个关键字都能省略。(注意:大括号,逗号,return关键字,要么一起省略,要么都不省略。)

    最后再说一个可以简化Lambda表达式的情况,就是当接口中的方法只有一个参数时,连填写参数的小括号都可以省略,这里就不演示了。

    展开全文
  • Java中Lambda表达式

    2019-05-05 22:09:23
    lambda表达式Java 8添加,并提供以下功能。 允许将功能视为方法参数,或将代码视为数据。 可以在不属于任何类的情况下创建的函数。 lambda表达式可以像传递对象一样传递,并按需执行。 // Java ...

    Lambda表达式基本上表示功能接口的实例(具有单个抽象方法的接口称为功能接口。例如java.lang.Runnable)。lambda表达式实现唯一的抽象函数,因此实现了功能接口

    lambda表达式在Java 8中添加,并提供以下功能。

    允许将功能视为方法参数,或将代码视为数据。
    可以在不属于任何类的情况下创建的函数。
    lambda表达式可以像传递对象一样传递,并按需执行。

    // Java program to demonstrate lambda expressions 
    // to implement a user defined functional interface. 
    // A sample functional interface (An interface with 
    // single abstract method 
    interface FuncInterface 
    { 
    	// An abstract function 
    	void abstractFun(int x); 
    
    	// A non-abstract (or default) function 
    	default void normalFun() 
    	{ 
    	System.out.println("Hello"); 
    	} 
    } 
    
    class Test 
    { 
    	public static void main(String args[]) 
    	{ 
    		// lambda expression to implement above 
    		// functional interface. This interface 
    		// by default implements abstractFun() 
    		FuncInterface fobj = (int x)->System.out.println(2*x); 
    
    		// This calls above lambda expression and prints 10. 
    		fobj.abstractFun(5); 
    	} 
    } 
    
    输出:10
    
    句法: lambda运算符 - >正文
    

    重点:

    lambda表达式的主体可以包含零个,一个或多个语句。

    当存在单个语句时,大括号不是必需的,并且匿名函数的返回类型与正文表达式的返回类型相同。

    如果有多个语句,则必须用大括号(代码块)括起来,并且匿名函数的返回类型与代码块中返回的值的类型相同,如果没有返回任何内容,则返回void 。

    展开全文
  • 对于任何场景而言,代码量永远都是越少越好,而Java8提供的Lambda表达式正式简化代码的利器。参考博客:Java 8 Lambda 表达式详解参考博客:完美的lambda表达式只有一行在 Java 8 以前,若我们想要把某些功能传递...

    对于任何场景而言,代码量永远都是越少越好,而Java8中提供的Lambda表达式正式简化代码的利器。

    参考博客:Java 8 Lambda 表达式详解

    参考博客:完美的lambda表达式只有一行

    在 Java 8 以前,若我们想要把某些功能传递给某些方法,总要去写匿名类。

    manager.addScheduleListener(new ScheduleListener() {

    @Override

    public void onSchedule(ScheduleEvent e) {

    // Event listener implementation goes here...

    }

    });

    Java 是面向对象语言,除了原始数据类型之处,Java 中的所有内容都是一个对象。而在函数式语言中,我们只需要给函数分配变量,并将这个函数作为参数传递给其它函数就可实现特定的功能。JavaScript 就是功能编程语言的典范(闭包)。也就是说Java中方法参数只有两种:一是基础数据类型,一是对象。为了兼容函数式编程,而出现了Lambda表达式。

    什么是Lambda表达式

    Java 中的 Lambda 表达式通常使用语法是 (argument) -> (body),比如:

    (arg1, arg2...) -> { body }

    (type1 arg1, type2 arg2...) -> { body }

    如果Lambda表达式只有一行,则不需要{}、return、或者;,比如:

    (Integer e) -> e*2

    再比如Lambda要创建一个比较器:

    Comparator c = (p1, p2) -> p1.getAge().compareTo(p2.getAge());

    甚至于:

    Comparator c = Comparator.comparing(Person::getAge);

    在这里的::就是Java中的方法引用。

    功能接口

    在 Java 中,功能接口(Functional interface)指只有一个抽象方法的接口。

    每个 Lambda 表达式都可以隐式地分配给功能接口。例如,我们可以从 Lambda 表达式创建 Runnable 接口的引用,如下所示:

    Runnable r = () -> System.out.println("hello world");

    编译器会自动将上面的代码编译为:

    new Thread(

    () -> System.out.println("hello world")

    ).start();

    Lambda 表达式的例子

    线程初始化

    // Old way

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println("Hello world");

    }

    }).start();

    // New way

    new Thread(

    () -> System.out.println("Hello world")

    ).start();

    事件处理

    // Old way

    button.addActionListener(new ActionListener() {

    @Override

    public void actionPerformed(ActionEvent e) {

    System.out.println("Hello world");

    }

    });

    // New way

    button.addActionListener( (e) -> {

    System.out.println("Hello world");

    });

    遍例输出(方法引用)

    // old way

    List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

    for (Integer n : list) {

    System.out.println(n);

    }

    // 使用 -> 的 Lambda 表达式

    list.forEach(n -> System.out.println(n));

    // 使用 :: 的 Lambda 表达式

    list.forEach(System.out::println);

    逻辑操作

    package com.wuxianjiezh.demo.lambda;

    import java.util.Arrays;

    import java.util.List;

    import java.util.function.Predicate;

    public class Main {

    public static void main(String[] args) {

    List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

    System.out.print("输出所有数字:");

    evaluate(list, (n) -> true);

    System.out.print("不输出:");

    evaluate(list, (n) -> false);

    System.out.print("输出偶数:");

    evaluate(list, (n) -> n % 2 == 0);

    System.out.print("输出奇数:");

    evaluate(list, (n) -> n % 2 == 1);

    System.out.print("输出大于 5 的数字:");

    evaluate(list, (n) -> n > 5);

    }

    public static void evaluate(List list, Predicate predicate) {

    for (Integer n : list) {

    if (predicate.test(n)) {

    System.out.print(n + " ");

    }

    }

    System.out.println();

    }

    }

    Stream API 示例

    // old way

    List list = Arrays.asList(1,2,3,4,5,6,7);

    for(Integer n : list) {

    int x = n * n;

    System.out.println(x);

    }

    // new way

    List list = Arrays.asList(1,2,3,4,5,6,7);

    list.stream().map((x) -> x*x).forEach(System.out::println);

    展开全文
  • Java中lambda表达式

    2019-03-01 13:24:36
    Java8引入了很多新特性,其中就包括了Lambda 表达式以及stream,今天就通过简单几句话说说lambda到底是个什么东西。 首先lambda作用是什么? Lambda 表达式可以使代码变的更加简洁,换句话说就是让你可以写出优雅...

    Java8引入了很多新特性,其中就包括了Lambda 表达式以及stream,今天就通过简单几句话说说lambda到底是个什么东西。

    首先lambda作用是什么?

             Lambda 表达式可以使代码变的更加简洁,换句话说就是让你可以写出优雅的代码

    public static void main(String[] args) {
            final int num=10;
            //1.7
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(num);
                }
            });
            //1.8
            Thread thread1=new Thread(()-> System.out.println(num));
    
            thread.start();
            thread1.start();
        }

         上面我们使用lambda表达式替换掉了匿名内部类使得代码变得更加简洁了

    lambda表达式是什么

    那么lambda表达式是什么呢?

            java8允许将一个函数写成lambda表达式的形式作为参数传入方法中

    那么这是一个怎么样的函数呢?

            他其实就是接口中方法的实现,这个函数在一个接口中被定义,并且这个接口只能定义它一个函数这种接口叫做“函数式接口”

    也就是说lambda其实是接口中方法的实现,所以lambda表达式的参数及返回类型需要和接口中方法一致

     

    我们来对上边的例子来进行修改便于更容易理解:

    首先新建MyThread类继承runnable接口

    public class MyThread implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i <10 ; i++) {
                System.out.println("1.7 print :" +i);
            }
        }
    }

    然后去创建线程

    public static void main(String[] args) {
            final int num=10;
            //1.7
            Runnable runnable1=new MyThread();
            Thread thread1=new Thread(runnable1);
    
            //1.8
            Runnable runnable2=()-> {
                for (int i = 0; i <num ; i++) {
                    out.println("1.8 print :"+i);
                }};
            Thread thread2=new Thread(runnable2);
    
            thread1.start();
            thread2.start();
    
        }

           从上面代码中可可以看出,不使用lambda需要新建类去继承runnable接口。而使用lambda可以很方便的实现方法并作为参数传入方法中。

    再来看看runnable接口,他的确只定义了一个方法,并且通过@FunctionalInterface注解标注防止定义其他方法使它变成“非函数式接口”

    @FunctionalInterface
    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

    最后在来看看其他几种lambda表达式的形式

     * () -> 5  无参返回 5
     * x -> 2 * x  参数为x 返回2x
     * (x, y) -> x – y  两个参数,返回x-y
     * (int x, int y) -> x + y  两个int型参数
     * (String s) -> System.out.print(s)  无返回值或者说返回void

     

     

     

     

     

    展开全文
  • java中lambda表达式

    2021-05-14 10:28:40
    lambda 表达式形式:参数, 箭头(->) 以及一个表达式。如 果代码要完成的计算无法放在一个表达式中,就可以像写方法一样,把这些代码放在 { },并包含显式的 return语句 (String first, String second) -> ...
  • java中Lambda表达式

    2020-11-05 11:25:53
    Lambda表达式 看做匿名函数;没有名称,但是有参数列表、返回类型、可能还有一个可以抛出的异常列表 特性: 匿名—:不像普通方法一样有特定方法名称 函数—:不像方法属于某个特定的类 传递—:可以作为参数传递给...
  • 主要介绍了Java中Lambda表达式之Lambda语法与作用域解析重点介绍Lambda表达式基础知识,需要的朋友可以参考下
  • Java8 Lambda表达式教程

    万次阅读 多人点赞 2013-10-16 16:08:07
    Java8新特性,Lambda表达式与集合类bulk operation教程。迄今为止最全面的中文原创java lambda表达式教程。
  • Java中Lambda表达式的使用

    万次阅读 多人点赞 2019-03-26 17:39:22
    Lambda表达式Java SE 8一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。...
  • 主要介绍了Java中Lambda表达式并行与组合行为,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • 什么是 Lambda表达式?对于 Java 的 lambda 表达式,我们可以把它简单的理解为一个函数。比如,我们需要这样一个函数,它需要把两个数字相加,将结果返回 则可以这样定义1int add(int a, int b);但是我们知道,...
  • Java中Lambda表达式学习

    2021-02-18 16:25:09
    Java中Lambda表达式学习 ​ 上一篇博客了解了线程的相关学习,学习的过程中看到一个注解@FunctionalInterface,本次的博客就来学习一下函数式接口。函数式接口可以用Lambda来创建,所以函数式接口的学习应该在Lambda...
  • JAVA 中Lambda表达式

    2017-11-07 16:23:25
    使用Lambda表达式如下 interface IMath{ public int compare ( int x, int y); } public class Hello{ public static void main (String []args){ IMath m = (x,y) -> x>y?x:y; System. ...
  • 1.标准语法考虑以下示例:String[] arr = {"program", "creek", "is", "a", "java", "site"};Arrays.sort(arr, (String m, String n) -> Integer.compare(m.length(), n.length()));System.out.println(Arrays....
  • lambda表达式本文要搞清楚以下几点是什么为什么要用是否有其他选择能干什么应用场景优点缺点怎么用(重点)lambda表达式是什么lambda表达式JAVA8提供的一种新的特性,它支持JAVA也能进行简单的“函数式编程”。...
  • “Lambda 表达式”(lambda expression)是一个匿名函数,Lambda表达式基于数学的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。Lambda表达式可以表示闭包...
  • java中lambda表达式的基本使用 在java中使用lambda表达式的话,需要注意两点: 一个是lambda表达式本身的语法 另一个是函数式接口 lambda语法 java8新增了一个操作符-&gt;,称为lambda操作符或箭头操作...
  • Java lambda表达式Java 8的新增功能。Java lambda表达式Java进入函数式编程的第一步。一个Java lambda表达式它不属于任何类,而可以看作是一个可以创建的函数。一个Java lambda表达式可以作为对象传递并按需...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,238
精华内容 3,695
关键字:

java中lambda表达式

java 订阅