精华内容
下载资源
问答
  • JAVA中的Lambda表达式

    千次阅读 2021-03-28 16:32:01
    JAVA中的Lambda表达式 1.简介 1.Lambda表达式: JDK1.7版本以上推出新的特性,简单的说就是他没有声明的方法,也就是说没有访问修饰词,返回值等。 Lambda表达式用于创建匿名内部类所属的接口,必须只能有一个抽象...

    JAVA中的Lambda表达式

    1.简介

    1.Lambda表达式:
    • JDK1.7版本以上推出新的特性,简单的说就是他没有声明的方法,也就是说没有访问修饰词,返回值等。
    • Lambda表达式用于创建匿名内部类所属的接口,必须只能有一个抽象方法,否则不可以使用Lambda表达式。
    2.语法规则:

    (方法的参数)->{

    方法体

    }

    3.lambda表达式的标准格式由三部分组成:

    1.一些参数

    2.一个箭头

    3.一段代码

    4.格式说明:

    ():接口中抽象方法参数,没有参数就空着,有参数就写参数,有多个参数就使用逗号隔开.

    ->:传递的意思,把参数传递给方法体.

    {}:重写接口的抽象方法.

    2.Lambda无参形式

    1.创建自定义接口Test01

    要满足lambda表达式,那么该接口中有且只有一个抽象方法。

    public interface Test01 {
    	public static final int a=6;
    	public void demo();
    }
    
    2.对比匿名内部类和Lambda表达式

    在Lambda表达式中如果方法体中只有一行代码(不能有别的业务)则可以省略{},但不建议这样做。

    public class LambdaDemo1 {
    	public static void main(String[] args) {
    		//匿名内部类
    		Test01 t=new Test01() {
    			
    			public void demo() {
    				System.out.println("这是匿名内部类表达式实现了tast01接口中的方法");
    				
    			}
    		};
    		t.demo();
    		
    		//Lambda表达式
    		Test01 t2=()->{
    			System.out.println("这是lambda表达式实现了tast01接口中的方法");
    		};
    		t2.demo();
    	}
    }
    
    3.执行结果:

    这是匿名内部类表达式实现了tast01接口中的方法
    这是lambda表达式实现了tast01接口中的方法

    3.Lambda表达式的有参形式

    1.创建自定义接口Test02
    public interface Test02 {
    	public void demo2(int a);
    }
    
    2.创建Lambda表达式

    Lambda表达式,如果该参数只有一个,那么可以省略(),但是不建议这样写

    public class LambdaDemo2 {
    	public static void main(String[] args) {
    		//匿名内部类
    		Test02 t=new Test02() {
    			
    			public void demo2(int a) {
    				System.out.println("这是匿名内部类,a为"+a);
    				
    			}
    		};
    		t.demo2(9);
    		
    		//Lambda表达式,如果该参数只有一个,那么可以省略(),但是不建议这样写
    		Test02 t2=(a)->{
    			System.out.println("这是Lambda表达式,a的值为:"+a);
    		};
    		t2.demo2(80);
    	}
    }
    
    执行结果:

    这是匿名内部类,a为9
    这是Lambda表达式,a的值为:80

    4.Lambda表达式多个参数

    1.创建自定义接口Test03
    public interface Test03 {
    	public void demo3(String name,int age);
    }
    
    
    2.Lambda表达式
    public class LambdaDemo3 {
    	public static void main(String[] args) {
    		//Lambda表达式
    		Test03 t=(name,age)->{
    			System.out.println("我叫:"+name+",年龄:"+age);
    		};
    		t.demo3("刘永超", 90);
    	}
    }
    

    5.Lambda表达式有返回值没有参数

    1.创建自定义接口Test04
    public interface Test04 {
    	public int demo4();
    }
    
    2.Lambda表达式

    如果有返回值没有方法体,这时候可以省略return同时也省略大括号和分号,也就是return和{}还有“;”号,要不同时有,要不同时没有。

    public class LambdaDemo4 {
    	public static void main(String[] args) {
    		//匿名内部类
    		Test04 t=new Test04() {
    			public int demo4() {
    				System.out.println("这是匿名内部类");
    				return 20;
    			}
    		};
    		int n=t.demo4();
    		System.out.println(n);
    		
    		//Lambda表达式
    		//Test04 t2=()->10;  等效于  Test04 t2=()->{return 10;};
    		Test04 t2=()->{
    			System.out.println("这是lambda表达式");
    			return 10;
    		};
    		
    		int m=t2.demo4();
    		System.out.println(m);
    	}
    }
    
    
    3.执行结果:

    这是匿名内部类
    20
    这是lambda表达式
    10

    6.Lambda表达式有参数也有返回值

    1.创建自定义接口Test05
    public interface Test05 {
    	public double demo5(int a,double b);
    }
    
    2.Lambda表达式
    public class LambdaDemo5 {
    	public static void main(String[] args) {
    		//lambda表达式
    		Test05 t=(a,b)->{
    			System.out.println("a:"+a+"   b:"+b);
    			return a+b;
    		};
    		double d=t.demo5(30,66.3);
    		System.out.println(d);
    	}
    }
    
    3.执行结果:

    a:30 b:66.3
    96.3

    7.利用Lambda表达式完成线程任务

    public class LambdaDemo6 {
    	public static void main(String[] args) {
    		//匿名内部类
    		Runnable r=new Runnable() {
    			public void run() {
    				System.out.println("线程任务");
    				
    			}
    		};
    		Thread t=new Thread(r);
    		t.start();
    		
    		//Lambda表达式
    		Runnable r2=()->{
    			System.out.println("利用lambda表达式完成了线程任务");
    		};
    		Thread t2=new Thread(r2);
    		t2.start();
    		
    	}
    }
    
    执行结果:

    利用匿名内部类完成了线程任务
    利用lambda表达式完成了线程任务

    8.利用Lambda表达式对集合中的字符串进行排序

    public class LambdaDemo7 {
    	public static void main(String[] args) {
    		List<String> list=new ArrayList<String>();
    		list.add("小文学");
    		list.add("俄罗夫司机");
    		list.add("刘备");
    		list.add("刘永超西");
    		list.add("雅美爱的发声");
    		System.out.println("排序之前:");
    		for(String s:list){
    			System.out.println(s);
    		}
    		System.out.println();
    	
    		//Lambda表达式
    		//方式一:
    		Comparator<String> c=(o1,o2)->{
    			return o1.length()-o2.length();
    		};
    		//方式二:
    		//Comparator<String> c=(o1,o2)->o1.length()-o2.length();
    		
    		Collections.sort(list,c);
    		System.out.println("排序之后:");
    		for(String s:list){
    			System.out.println(s);
    		}
    	}
    }
    
    执行结果:

    排序之前:
    小文学
    俄罗夫司机
    刘备
    刘永超西
    雅美爱的发声

    排序之后:
    刘备
    小文学
    刘永超西
    俄罗夫司机
    雅美爱的发声

    9.@FunctionalInterface

    1.@FunctionalInterface 校验该接口是否满足Lambda表达式Lambda表达式;

    2.JDK1.7版本之上推出了在接口里也可以写普通方法但是一定要在方法前面添加default或者public static;

    @FunctionalInterface
    public interface LambdaDemo8 {
    	public void test();
    	
    	default public void test2(){
    		System.out.println("haha");
    	}
    	
    	public static void test3(){
    		System.out.println("heihei");
    	}
    }
    

    10.forEach()

    在JDK1.7版本以上支持一个方法forEach();

    例如:遍历List,Map都可以使用Lambda表达式来完成。

    public class LambdaDemo9 {
    	public static void main(String[] args) {
    		List<String> list=new ArrayList<String>();
    		list.add("one");
    		list.add("two");
    		list.add("three");
    		list.add("four");
    		
    		
    		//Lambda表达式forEach(Lambda表达式)
    		list.forEach((s)->{System.out.println(s);});
    		
    		Map<String,Integer> map=new HashMap<String,Integer>();
    		map.put("语文", 99);
    		map.put("数学", 100);
    		map.put("英语", 36);
    		map.put("化学", 94);
    		
    		//Lambda表达式遍历
    		map.forEach((k,v)->{System.out.println(k+" "+v);});
    		
    	}
    }
    
    执行结果:

    遍历list集合:
    one
    two
    three
    four
    遍历map集合:
    数学 100
    化学 94
    语文 99
    英语 36

    展开全文
  • Java中的Lambda表达式

    2020-07-13 16:40:18
    Java中的Lambda表达式Lambda表达式匿名内部类的简化使用场景:关于函数式接口的相关介绍Lambda表达式的简单介绍格式一:无参,无返回值格式二:有参数,无返回值格式三:有多个参数,无返回值格式四:有参数,有...

    Lambda表达式匿名内部类的简化

    使用场景:

    1、注意:这是JDK1.8之后新特性
    2、Lambda表达式使用的前提,就是接口必须是一个函数式接口
    

    关于函数式接口的相关介绍

    1、在接口中,只有一个抽象方法,那么这个接口就是函数式接口
    2、java8种提供了一些常用的函数式接口(消费型接口,供给型接口,函数型接口,断言型接口等等,读者可以自行查阅资料了解相关信息,这里不再介绍),在使用类似功能的时候,不需要额外定义接口,直接使用jdk中提供的即可。
    

    Lambda表达式的简单介绍

    1、是对匿名内部类对象的一种格式简化;
    2、Java1.8中引入了一个新的操作符“->”,称之为箭头运算符,或者Lambda运算符;
    3、“->”作用:就是用于分隔前后两部分;
    4、“->”左边:表示Lambda表达式的参数列表(接口中,定义的抽象方法的参数)
    5、“->”右边:表示的是方法的方法体,Lambda体;
    6、语法格式有四种下面一一进行介绍。
    

    格式一:无参,无返回值

    //首先定义一个MyInter01 接口
    interface MyInter01 {
    	public abstract void test01();
    }
    //匿名内部类方式实现接口
    MyInter01 mi02 = new MyInter01(){
    	public void test01(){
    		System.out.println("匿名内部类的方式调用了");
    	}
    };
    mi02.test01();
    //JDK1.8之后匿名内部类的简写格式:lambda 表达式实现接口
    MyInter01 mi03 = () -> System.out.println("无参数无返回值类型Lambda表达式的方式调用了");
    mi03.test01();
    

    格式二:有参数,无返回值

    //首先定义一个MyInter01 接口
    interface MyInter01 {
    	public abstract void test01(int num);
    }
    MyInter01 mi03 = (int num) -> System.out.println(num);
    mi03.test01(666);
    //当只要接收一个参数的时候可以省略“->”前面括号中的参数类型,以及括号,但是建议留着。
    

    格式三:有多个参数,无返回值

    //首先定义一个MyInter01 接口
    interface MyInter01 {
    	public abstract void test01(int a,int b);
    }
    MyInter01 mi03 = (x,y) -> System.out.println(x+y);
    mi03.test01(600,66);
    

    格式四:有参数,有返回值

    //首先定义一个MyInter01 接口
    interface MyInter01 {
    	public abstract int test01(int a,int b);
    }
    //若操作的语句有多句,要加上{}
    //若操作语句只有一句且是return语句,可以省略return
    MyInter01 mi03 = (x,y) -> {
    int sum = x + y;
    return sum;
    };
    int s = mi03.test01(600,66);
    System.out.println(s);
    
    展开全文
  • Java中的lambda表达式

    2021-02-15 08:16:56
    目录 1. 什么是lambda表达式? 2. 为什么要引入lambda...lambda表达式Java 8及其后续版本引入一种语言特性,它是一个能接受输入,处理后得到返回结果代码段。例如:(x,y)->{Math.pow(x,2)+Math.pow(y,2)}

    目录

    1. 什么是lambda表达式?

    2. 为什么要引入lambda表达式?

    3. 什么情况下使用lambda表达式?

    4. 如何使用lambda表达式?

    4.1 lambda表达式标准写法

    4.2 lambda表达式的简化

    4.3 lambda表达式使用示例


    1. 什么是lambda表达式?

    lambda表达式是Java 8及其后续版本引入的一种语言特性,它是一个能接受输入,处理后得到返回结果的代码段。例如:(x,y)->{Math.pow(x,2)+Math.pow(y,2)},就是一个输入为x和y,输出为它们的平方和的代码段。

    lambda表达式强调的是“给定什么,处理后得到什么”这一处理过程本身,不关心这个过程是由哪个对象完成的,它借鉴了函数式编程的简单易用的哲学思想。

    2. 为什么要引入lambda表达式?

    在一些应用开发场景中,我们需要的往往仅仅是一段可执行的代码,至于这段代码由哪个对象来完成,根本不重要,也用不着给这段代码起一个方法名或函数名。例如,在使用Thread类的带参构造方法Thread(Runnable  runnable)创建一个Thread对象时,我们仅仅需要的是一段在新创建的线程对象中执行的代码段,至于这个代码段是由哪个Runnable对象负责的、它是什么名称,都不重要。此时,如何处理这一情况?

    传统面向对象方法的实现流程是,创建一个实现Runnable接口的匿名类的对象,代码如下:

    Thread thread2=new Thread(new Runnable() {  //匿名Runnable对象

                         @Override

                         public void run() {              

                                ...  //要执行的代码段

                         }    

                  });

    上述代码最关键的部分是run方法中要执行的代码段,至于这个匿名类的对象,run方法名都只是形式上的,没有实际作用。在这种场景下,可以用lambda表达式简化上述代码:

    Thread thread2=new Thead(()->{... //要执行的代码段});

    可见,lambda表达式,省掉了面向对象的条条框框,只关心处理过程,不关心该过程的负责对象及过程名称。它遵循极简主义,可极大地简化代码。它特别适用于需要一段“临时需要、用后即扔”的代码的场景。

    3. 什么情况下使用lambda表达式?

    lambda表达式是为了在不需要对象、不需要方法名称的情形下代替匿名对象而存在的。具体而言,只要满足下列两个条件的任意一个,即可用lambda表达式:

    (1)某方法中的某个参数的类型为接口,且该接口仅包含1个抽象方法(这种接口称为函数式接口);

    (2)某个局部变量的类型为接口,且该接口仅包含1个抽象方法。

    在上述情况下,可以创建一个lambda表达式,它相当于一个匿名对象(记住:只是相当于,但不等价于,因为匿名类在编译时,会产生与匿名类相对应的class文件,而lambda表达式不会)。

    • 4. 如何使用lambda表达式?

      4.1 lambda表达式标准写法

    (参数列表)->{

     代码块

    }

    示例1:不带参数、无返回值的lambda表达式

    ()->{

     System.out.println("yes");

    }

    示例2:不带参数、有返回值的lambda表达式

    ()->{

     int a=3;

     int b=4;

     return a+b;

    }

    示例3:带参数、无返回值的lambda表达式

    (double a,double b)->{

        System.out.println("a+b"+(a+b));

    }

    示例4:带参数、有返回值的lambda表达式

    (double a,double b)->{

        return a+b;

    }

    4.2 lambda表达式的简化

    lambda表达式的书写遵循“能够根据上下文推断出的部分,就可以省略“”的原则。下面列出了三种可以简化lambda表达式的条件及简化方案:

    (1)带参数的lambda表达式中的参数类型可以省略。例如,上面的示例3可以简写为:

    (a, b)->{

        System.out.println("a+b"+(a+b));

    }

     

    (2)仅带一个参数,则参数左右的小括号可以省略。例如:

    a->{

    b=a+5;

    return b;

    }

    (3)如果代码块只包含一条语句,可省略代码块两边的大括号、return关键字(如果有的话)及这条语句后面的分号。例如:

    (a,b)->a+b    //返回a,b之和

    4.3 lambda表达式使用示例

    假设有一个GUI程序,主界面上包含2个文本框(txtA、txtB),一个按钮(btnComputing),希望在txtA中输入一个整数a后,单击该按钮时,执行一段代码,求小于a的所有完数,输出到txtB中。由于这个计算过程太耗时,为避免其阻塞主窗口线程,将其放到一个线程中执行。这时候,可以利用lambda表达式,参考代码如下:

    btnComputing.addActionListener(
                    e->{
                        try {
                            btnComputing.setEnabled(false);
                            txtB.setText("");
                            StringBuilder sb=new StringBuilder();
                            int a=Integer.valueOf(txtA.getText());
                            Runnable r=()->{    
                                for(int k=2;k<a;k++) {
                                    if(PerfectNumber.isYes(k)) {
                                        sb.append(" "+k);
                                        synchronized(this) {
                                        txtB.setText(sb.toString());                    
                                        }
                                    }
                                }
                                btnComputing.setEnabled(true);
                                btnComputing.setText("开始计算");
                            };
                            btnComputing.setText("计算中...");
                            new Thread(r).start();
                        } catch (NumberFormatException e1) {
                            JOptionPane.showMessageDialog(null, "请输入一个整数!");
                            btnComputing.setEnabled(true);
                            txtA.requestFocus();
                        }
                    }
            );

    注:这里的addActionListener里面的参数就是一个lambda表达式,而r也是一个lambda表达式对象。

    展开全文
  • java中的Lambda表达式

    2020-01-04 21:35:39
    java中的Lambda表达式由三部分组成: 1.一些参数 2.一个箭头 3.一段代码 格式:(参数列表) -> {一些重写方法的代码} // 1. 不需要参数,返回值为 5 () -> 5 // 2. 接收一个参数(数字类型),返回其2倍的值 x...

    java中的Lambda表达式由三部分组成:
    1.一些参数
    2.一个箭头
    3.一段代码
    格式:(参数列表) -> {一些重写方法的代码}

    // 1. 不需要参数,返回值为 5  
    	() -> 5  
    // 2. 接收一个参数(数字类型),返回其2倍的值  
    	x -> 2 * x  
    // 3. 接受2个参数(数字),并返回他们的差值  
    	(x, y) -> x – y  
    // 4. 接收2个int型整数,返回他们的和  
    	(int x, int y) -> x + y  
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
    	(String s) -> System.out.print(s)
    
    // Lambda表达式有参数有返回值的写法
    public class MainLambda {
        public static void main(String[] args) {
            Person[] arr = {
                new Person("jack", 22),
                    new Person("rose", 18),
                    new Person("tom", 25)
            };
            Arrays.sort(arr, (Person p1, Person p2)->{
                return p1.age - p2.age;
            });
            for (Person p : arr) {
                System.out.println(p);
            }
        }
    }
    

    注:使用Lambda必须要有接口,且接口中有且仅有一个抽象方法

    备注:有且只有一个抽象方法的接口称为函数式接口

    展开全文
  • Java中的Lambda表达式Lambda表达式是什么Lambda表达式是一个匿名函数,是在jdk1.8中添加的在jdk1.8之前,我们只能使用匿名方法和继承接口来实现接口中定义的方法Lambda表达式的使用也是有限制的,Lambda表达式只能在...
  • Lambda表达式是Java SE 8中一个重要的新特性。这篇文章主要介绍了Java中的Lambda表达式 ,需要的朋友可以参考下
  • java中的lambda表达式

    2020-08-04 22:39:16
    而我们要学习的Lambda表达式就是函数式思想的体现 2.Lambda表达式的标准格式 格式: ​ (形式参数) -> {代码块} 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可 ->:由英文画...
  • Java 中的Lambda表达式

    2019-12-17 00:18:05
    Java8给我们带来了 Lambda表达式和Stream流式操作,提供了函数式编程和简化批处理操作。可能大家日常使用很多,但是很少去关注Lambda 和 Stream实现。本篇就带着大家一起关注这两块知识,搬好小板凳我们一起看...
  • Java中的Lambda表达式 Lambda表达式是什么 Lambda表达式是一个匿名函数,是在jdk1.8中添加的 在jdk1.8之前,我们只能使用匿名方法和继承接口来实现接口中定义的方法 Lambda表达式的使用也是有限制的,Lambda表达式...
  • 主要介绍了深入理解Java中的Lambda表达式,Lambda在各编程语言中都是非常重要的特性,而Java中则加入得有些太晚...需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,904
精华内容 3,561
关键字:

java中的lambda表达式

java 订阅