JAVA进阶知识点总结 7-线程池、Lambda、函数式接口(生产者接口,消费者接口,函数接口,判断接口)

最新推荐文章于 2023-09-23 22:19:48 发布
最新推荐文章于 2023-09-23 22:19:48 发布
阅读量639 收藏 2
点赞数
分类专栏： java基础知识点 文章标签： java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adamcafe/article/details/88919959
版权

01.第一章：线程池_概念及作用：

1).什么是“线程池”：指封装了很多的“线程对象”的一个容器。

2).作用：内部的这些线程对象可以被“重复使用”；
线程对象每次使用完成后，会自动成为垃圾，不能再次的start。如果想要再次使用就需要再创建一个线程对象，但创建一个线程对象需要很大的系统开销，所以如果需要大量的、反复的执行同一线程会降低程序的效率。所以提出了“线程池”的概念。

02.第一章：线程池_示例：

在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        /*MyThread t1 = new MyThread();//需要5秒
        t1.start();//鼓掌...

        //过一会，还需要鼓掌的线程
        t1 = new MyThread();//需要5秒
        t1.start();//再次鼓掌....*/

        //使用线程池;
        //1.获取一个线程池对象;
        ExecutorService service = Executors.newFixedThreadPool(20);//表示创建一个可以容纳2个核心的线程的"线程池"对象
        //2.让线程池去执行，并缓存一个线程对象
        MyThread t = new MyThread();//需要5秒
        service.submit(t);//被第一次执行...
        //3.重复执行之前的线程
        System.out.println("再次执行鼓掌线程.....");
        service.submit(t);//被第二次执行
    }
}

在这里插入图片描述

03.第一章：线程池_实现线程的方式三_Callable接口：

1).之前我们学了两种实现线程的方式：

1).继承自Thread，重写run()
2).实现Runnable接口，重写run()
注意：上面两种方式都是run()，而这个run()方法有个缺点：不能返回值
如果我们希望“线程中”为主线程返回一些数据，之前的两种方式是做不到的。

2).从JDK5开始，又提供了实现线程的第三种方式：实现Callable接口，重写call()方法(相当于run()).

但这个方法可以返回值。 注意：Callable接口的方式实现线程，需要“线程池”来运行；

3).Callable接口与之前的两种方式的重要区别：Callable接口的方式可以返回值
3).示例代码：

/*
    制作一个线程，这个计算1--100的累加和，并将结果返回给主线程
*/

public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            sum += i;

        }
        return sum;
    }
}
		测试类：
public class Demo {
    public static void main(String[] args) 
				throws ExecutionException, InterruptedException {
        //1.创建一个线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);

        //2.创建MyCallable对象
        MyCallable myCall = new MyCallable();
        //3.让线程池去执行这个线程
        Future<Integer> future = service.submit(myCall);

        Integer result = future.get();//获取结果
        System.out.println("主线程收到的结果是：" + result);
    }
}

在这里插入图片描述

04.第二章：Lambda表达式_示例：

1).示例代码：

	1).定义一个接口：
	
public interface Animal {
    public void eat();
}

在这里插入图片描述

05.第二章：Lambda表达式_函数式编程思想_相对于面向对象的优点：

1).面向对象的方式：定义类，并创建对象，传递实参，调用方法；
2).Lambda：不需要制作类，不需要创建对象，直接传递一个“方法”作为实参；
可以节省代码的编写。

06.第二章：Lambda表达式_Lambda的标准格式【重点掌握】：

	fun(()->{
		System.out.println("小猪吃草...");
		}
	);

1).一对小括号：表示形参
2).一个右箭头：->
3).一对大括号：方法体
在这里插入图片描述

07.第二章：Lambda表达式_Lambda的前提条件

1).必须要有一个“接口”；
2).接口中有、且只有一个“抽象方法”(可以定义参数、返回值) 这是函数式接口

1).必须有、且只有一个抽象方法；
2).其它静态方法、默认方法有没有、有多少都无所谓

3).Lambda几种常见的形式：
//1.作为形参:
public static void main(String[] args) {
//1.调用方法，传递实参时–前提：方法的形参必须是：接口，而且里面有，且只有一个抽象方法
fun(()->{
System.out.println(“小猪吃草…”);
});

//2.声明变量：

Animal a = ()-> {
            System.out.println("小猪吃草...");
            };

//3.作为返回值

  Animal animal = getAnimal();
    animal.eat();
}
public static void fun(Animal a){
    a.eat();
}

public static Animal getAnimal(){
    /*return new Animal() {
        @Override
        public void eat() {
            System.out.println("小猪吃草...");
        }
    };*/
    return () ->{
        System.out.println("小猪吃草...");
    };
}

08.第二章：Lambda表达式_Lambda的标准格式_参数和返回值：

//1.定义一个接口，接口中抽象方法是：带参、带返回值

   public interface MyMath {
        public int calc(int a,int b);
    }

//2.调用
public class Demo {
public static void main(String[] args) {
//1.匿名内部类

fun(new MyMath() {
    @Override
    public int calc(int a, int b) {
        return a + b;
    }
    },10,20);

//2.使用Lambda–由于接口中的方法是带参、带返回值的，所以导致Lambda也要带参，带返回值

       fun((int a, int b)-> {
            return a * b;
        },10,20);

    }

    public static void fun(MyMath myMath,int m,int n) {
        int r = myMath.calc(m,n);
        System.out.println("结果是：" + r);
    }
}

在这里插入图片描述

09.第二章：Lambda表达式_Lambda的省略格式及省略规则

1).关于Lambda表达式的参数：
在这里插入图片描述

1).形参的“数据类型”都可以省略 fun((a, b)-> {
return a * b;
},10,20);

2).如果只有一个形参，可以同时省略：数据类型，一对小括号；
(如果省略小括号，必须省略数据类型)

1).定义一个接口：

    public interface MyMath2 {
        public void calc(int a);
    }
2).测试类：
			
    public class Demo {
        public static void main(String[] args) {
            fun( a ->{//形参只有一个，可以同时省略：小括号和数据类型
                System.out.println(a);
            },10);
        }
        public static void fun(MyMath2 myMath2,int m){
            myMath2.calc(m);
        }
    }

2).关于Lambda表达式的方法体：
1).如果方法体中只有一句话：可以同时省略：一对大括号，return关键字，这条语句后面的分号
要省全省，要用全用
在这里插入图片描述

示例一：

1).定义一个接口：
		
public interface MyMath2 {
    public void calc(int a);
}

2).测试类：

public class Demo {
    public static void main(String[] args) {
        fun( a ->//形参只有一个，可以同时省略：小括号和数据类型
            System.out.println(a)//可以同时省略：大括号，语句后的分号
        ,10);
    }
    public static void fun(MyMath2 myMath2,int m){
        myMath2.calc(m);
    }
}

示例二：有参，有返回值：

1).定义一个接口：			
    public interface MyMath2 {
        public int calc(int a,int b);
    }

2).测试类：

public class Demo {
    public static void main(String[] args) {
	  //完整格式
        fun( (int a,int b) ->{
            return a + b;
		},10,20);
	  //省略格式
	  fun((a,b) -> a + b,10,20);

    }
    public static void fun(MyMath2 myMath2,int m,int n){
        int r = myMath2.calc(m,n);
	   System.out.println(r);
    }
}
	-------------------------------------------------------------
	
	小结省略规则：
	1).形参：数据类型可以省略
	2).形参：如果只有一个形参，可以同时省略：小括号，数据类型；
	3).方法体：如果只有一句话，可以同时省略：大括号，return关键字，词条语句后的分号。

10.第三章：接口在类库架构中的作用：

1).解开类和类之间的耦合

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

11.第三章：函数式接口_概述

1).有，且只有一个抽象方法的接口，叫：函数式接口；
2).通常为了使用Lambda表达式，所以经常会特意的定义一些“函数式接口”。
3).为了避免定义函数式接口错误，Java为我们提供了一个“注解”，它类似于"@Override"注解，给编译器看的，
	   让编译器为我们检查这个接口是否是一个合格的函数式接口。
	   注解名：@FactionalInterface

4).示例代码：
@FunctionalInterface//作用：保证我们定义的接口是一个合格的函数式接口
public interface Animal {
    public void eat();
   
}

12.第三章：函数式接口_Supplier接口(生产者接口)

在这里插入图片描述
1).函数式接口原型：
T get()
2).示例代码：

public class Demo {
public static void main(String[] args) {
        //1.使用匿名子类对象
	fun(new Supplier<String>() {
    		@Override
   		 public String get() {
        		return "HelloWorld!";
    		}
	});
``
	//2.使用Lambda
	fun(()->{return "HelloWorld!";});

   }
   //下面的方法预先定义好的
     //此方法需要一个Supplier的子类对象，为fun()返回一个String对象
    public static void fun(Supplier<String> s){
	 String s = s.get();
	 System.out.println(s);

   }
}

13.第三章：函数式接口_Consumer接口(消费者接口)

在这里插入图片描述
1).抽象方法原型：
void accept(T t);
示例代码：

public class Demo {
    public static void main(String[] args) {
        //1.使用匿名内部类调用
        
    fun(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println("转换为大写输出：" + s.toUpperCase());
        }
    },"Hello");

       //2.使用Lambda表达式
 

           fun(t -> System.out.println("转换为小写：" + t.toLowerCase()), "Hello");
        }
        //此方法需要一个Consumer和一个String
        //此方法内部会将String传给Consumer，子类决定做什么
        public static void fun(Consumer<String> c,String s){
            c.accept(s);
        }
    }

2).默认方法：
andThen()
作用：当需要连续的两次处理同一数据时，可以使用这个方法
示例代码：

public class Demo {
    public static void main(String[] args) {
        fun(s-> System.out.println("转换为大写：" + s.toUpperCase()),
                s -> System.out.println("转换为小写：" + s.toLowerCase()),
                "HelloWorld");

    }
        //andThen
    public static void fun(Consumer<String> c1,Consumer<String> c2,String str){
        //先调用c1.accept()然后再调用c2.accept()
       /* c1.accept(str);
        c2.accept(str);
*/
       //等同于上面的写法
       c1.andThen(c2).accept(str);//内部就是先调用c1.accept()然后再调用c2.accept()
    }
}

14.第三章：函数式接口_Function接口(函数)

1).抽象方法原型：
R apply(T t):接收第一个泛型类型，返回第二个泛型类型
通常是用于做“转换”。

2).默认方法：
andThen:当需要将一个数据进行两次连续的转换时，可以使用此方法。
示例代码：

public class Demo {
    public static void main(String[] args) {
        fun(s -> Integer.parseInt(s) + 10,n -> Integer.toString(n),"25");
    }
    
    //andThen：将一个String转换为Integer，然后 + 10 ，然后再转换为String
    public static void fun(Function<String,Integer> f1,Function<Integer,String> f2,String age){
        /*Integer intAge = f1.apply(age);
        String str = f2.apply(intAge);*/
        String str = f1.andThen(f2).apply(age);
        System.out.println("字符串的结果：" + str);
    }
}

15.第三章：函数式接口_Predicate接口(判断接口)

在这里插入图片描述
1).抽象方法原型：

	boolean test(T t);
	    示例代码：
public class Demo {
    public static void main(String[] args) {
    //1.匿名内部类
    
fun(new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return s.length() >= 5;
    }
}, "Hell");

//2.使用Lambda

        fun(s -> s.length() >= 5,"Hell");
    }

    public static void fun(Predicate<String> p,String s){
        boolean b = p.test(s);
        System.out.println("判断的结果：" + b);
    }
}

2).默认方法：
1).and():可以将两个Predicate的判断做逻辑与的判断；

public class Demo {
    public static void main(String[] args) {
        //验证一个字符串是否即包含大写的H，又包含大写的W
        fun(s->s.contains("H"),s-> s.contains("W"),"HelloWorld");
    }  


//定义一个方法，可以对一个字符串进行两个判断，可以打印：两个判断的"并且"的结果

    public static void fun(Predicate<String> p1,Predicate<String> p2,String s){
        /*boolean b1 = p1.test(s);
        boolean b2 = p2.test(s);
        System.out.println(b1 && b2);*/
        
    //等同于上面的效果
        boolean b2 = p1.and(p2).test(s);
    }
}

2).or():可以将两个Predicate的判断做逻辑或的判断；
3).negate():将一个Predicate的判断“取反”:

学习目标总结：

01.能够描述Java中线程池运行原理
1).可以缓存多个“线程对象”，并且可以将这些“线程对象”进行“重用”，这样可以大大降低创建线程对象的次数，提高程序的运行效率。
02.能够理解函数式编程相对于面向对象的优点
1).不用定义类，不用创建对象，直接传递方法体；代码简洁
03.能够掌握Lambda表达式的标准格式
1).一个小括号：形参
2).一个右箭头：语法
3).一对大括号：方法体
04.能够掌握Lambda表达式的省略格式与规则
省略规则：
1).形参：形参类型都可以省略；
2).形参：如果只有一个形参，可以同时省略：小括号，数据类型；
3).方法体：如果方法体中只有一句话，可以同时省略：大括号，return，分号。
05.能够明确Lambda的两项使用前提
1).必须是接口；
2).必须是“函数式接口”–有，且只有一个抽象方法。
06.能够使用Supplier函数式接口
1).生产者接口：没有参数，只有返回值
2).
public static void main(String[] args) {
//1.使用匿名子类对象
fun(new Supplier() {
@Override
public String get() {
return “HelloWorld!”;
}
});
//2.使用Lambda
fun(()->{return “HelloWorld!”;});
}

public static void fun(Supplier s){
String str = s.get();
System.out.println(str);
}

07.能够使用Consumer函数式接口
1).消费者接口：只有参数，没有返回值
public static void main(String[] args) {
//1.使用匿名内部类调用
fun(new Consumer() {
@Override
public void accept(String s) {
System.out.println(“转换为大写输出：” + s.toUpperCase());
}
},“Hello”);

    //2.使用Lambda表达式
    fun(t -> System.out.println("转换为小写：" + t.toLowerCase()), "Hello");
    
}
//此方法需要一个Consumer和一个String
//此方法内部会将String传给Consumer，子类决定做什么
public static void fun(Consumer<String> c,String s){
    c.accept(s);
}

08.能够使用Function函数式接口
1).函数接口：有入、有出
public class Demo {
public static void main(String[] args) {
//1.使用匿名内部类
fun(new Function<Integer, String>() {
@Override
public String apply(Integer value) {
return value.toString();
}
},25);

    //2.使用Lambda
    fun(a -> a.toString(),25);
}
//此方法需要一个具有Integer和String泛型的Function子类对象
//方法内部调用Function子类的apply，接收一个Integer,返回一个String

public static void fun(Function<Integer,String> fun,int age){
    String s = fun.apply(age);
    System.out.println("字符串的值：" + s);

}

}

09.能够使用Predicate函数式接口
1).判断接口：接收一个数据，返回一个boolean
public static void main(String[] args) {
//1.匿名内部类
fun(new Predicate() {
@Override
public boolean test(String s) {
return s.length() >= 5;
}
}, “Hell”);

//2.使用Lambda
fun(s -> s.length() >= 5,"Hell");

}

public static void fun(Predicate p,String s){
boolean b = p.test(s);
System.out.println(“判断的结果：” + b);

}

AdamCafe
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Lambda表达式和函数式接口实例分析
08-25
主要介绍了Java Lambda表达式和函数式接口,结合实例形式分析了Java8 Lambda表达式和函数式接口相关原理、用法及操作注意事项,需要的朋友可以参考下
Java：Stream三部曲（一）：函数式接口的理解与常用示例（Runnable、Comparator、Callable、Consumer、Predicate、Supplier、Function）
whx6666666的博客
11-24 2219
Stream流处理器入门第一步——函数式接口。本文主要包含关于函数式接口的简略基础概念、个人学习过程中的一些理解以及对当前JDK中内置的主要函数式接口的用法解析（包括Runnable、Comparator、Callable、Consumer、Predicate、Supplier、Function）。
Java8新特性之lambda表达式(带实例)及新接口(Consumer、Supplier、Function、Predicate)
shuai_ge_feng的博客
03-24 1923
lambda表达式什么是Lambda表达式函数式接口1使用案例2**来一个带参数的用法**3来一个带参数和返回值的方法引用如何构建方法引用跳过理论看案例函数式接口内置4大接口Predicate：断言型接口Consumer 接口(消费者) 什么是Lambda表达式 可以把Lambda表达式理解为可传递的匿名函数的一种方式 它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。这个定义够大的，让我们慢慢道来。 学习lambda表达式就要先知道函数式接口是什么？ 函数式接口 函数式接口（
【Java 基础篇】Java Consumer 接口详解
最新发布
繁依Fanyi的博客
09-23 4511
Consumer是Java 8中的一个函数式接口，它位于包中。它定义了一个名为accept的抽象方法，该方法接受一个参数并且不返回任何结果。换句话说，Consumer接口表示一个消费者，它可以对给定的对象执行某些操作，但不产生任何结果。ConsumerT是Consumer接口的泛型类型参数，表示输入类型。Consumer接口是Java 8中引入的一个函数式接口，用于表示一个消费者，它接受一个输入并执行某些操作。它在集合操作、数据处理、对象配置和异常处理等场景中非常有用。通过学习Consumer。
Java设计模式（四）—— 原型模式
weixin_49561506的博客
03-25 1059
设计模式的原型模式，介绍了三种原型模式实现方式的浅复制和深复制
Java函数式接口讲解与应用
AE86的博客
04-04 3205
最近业务代码编写中使用到了一个函数式接口 Consumer，巧妙地解决了代码复用的问题，既解决了业务需求，代码风格又优雅，而且高度内聚。下面直接上代码案例，然后再深入介绍Java8中的几个函数式接口：Function<T, R>ConsumerPredicateSupplier。最后结合使用场景以及Java逆向移植工具Retrolambda（点这了解Retrolambda）帮助读者加深对函数式接口的理解。 Consumer案例 需求背景 因涉及系统敏感信息，案例是经过脱敏、简化后的，不影响实际理
Java8简单了解Lambda表达式与函数式接口
08-28
主要介绍了Java8简单了解Lambda表达式与函数式接口，具有一定参考价值，需要的朋友可以了解下。
死磕Lambda表达式（四）：常用的函数式接口
01-20
在Java8支持Lambda表达式以后，为了满足Lambda表达式的一些典型使用场景，JDK为我们提供了大量常用的函数式接口。它们主要在 java.util.function 包中，下面简单介绍几个其中的接口及其使用示例。 Supplier接口 ...
java 函数式接口
12-22
函数式接口可以转化Lambda表达式。 2. 使用 2.1 @FunctionalInterface 注解使用 @FunctionalInterface 注解，作用是检查当前接口是否符合函数式接口的规范 @FunctionalInterface public interface FunctionalType { ...
JDK1.8【函数式接口】【定义与使用】【源码】
04-19
* 函数式接口，支持Lambda表达式 也就是说：参数可以长这样 "()->{}" * * JDK1.8内置,四种函数式接口 * 1.消费型 Consumer<T> return：无 * 2.提供型 Supplier<T> return： * 3.函数型 Function,R> return： ...
kafka 生产者消费者 api接口
梁小明的博客
07-29 3171
生产者 import java.util.Properties; import kafka.javaapi.producer.Producer; import kafka.producer.KeyedMessage; import kafka.producer.ProducerConfig; import kafka.serializer.StringEncoder;
什么是函数式接口和常用的函数式接口
weixin_48498902的博客
03-09 256
接口中有且只有一个 抽象方法的接口被称作函数式接口Java 中函数式编程体现就是 Lambda 表达式，所以对于 Lambda 表达式来说函数式接口尤为重要如何检测一个接口是不是函数式接口？@FunctionalInterface 注解，在定义接口的上方加上注解，编译可以通过就是函数式接口，否则不是【注意】
java中的函数式接口是什么？
weixin_42585386的博客
11-16 1032
java中的函数式接口是什么？
教你会用Lambda和Stream流
weixin_48991399的博客
03-04 251
首先需要明确的是，Stream流是在1.8版本及以上支持的。1.stream的功能：​ stream流可以对数据进行筛选，去重，按照规则排序，限制个数，跳过指定个数，最终处理等等，并且stream在对数据进行操作的时候不会对原始数据进行修改。collection集合stream()方法Arrays的stream方法。
java消费者接口应用_几个常用的Java接口之Consumer、Supplier、Predicate和Function
weixin_39758956的博客
02-27 905
Java8之Consumer、Supplier、Predicate和Function攻略！来聊聊Consumer、Supplier、Predicate、Function这几个接口的用法，在 Java8 的用法当中，这几个接口虽然没有明目张胆的使用，但是，却是润物细无声的。为什么这么说呢？这几个接口都在 java.util.function 包下的，分别是Consumer(消费型)、supplier...
生产者与消费者、Condition接口、JMM模型、java并发编程的三大特性
Y521316的博客
04-15 87
生产者与消费者、 Condition接口、JMM模型、java并发编程的三大特性、Callable接口
关于函数式接口中常用的Supplier、Consumer、predicate、Function的总结以及其使用场景
HelloWorld哥的博客
04-08 3781
函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部 类的“语法糖”
Java总结14 函数式接口Supplier供应者/Consumer消费者/Predicate判断/Function转换和Stream流的概念与应用
硬核编程乐乐的博客
01-04 1874
一.函数式接口的概念 函数式接口:接口中只有一个抽象方法. 函数式接口分为4个常用接口 1.Supplier供应者 2.Consumer消费者 3.Predicate判断 4.Function功能(多用于类型转换) 1.Supplier函数接口 概念:需要用到Lambda表达式.定义一个方法,方法里有一个已经存在的类作为其参数和返回值类型. 每当你调用这个方法时,都需要用Lambda表达式去重写...
Java生产者消费者的五种实现方式
zgj12138的博客
06-30 4345
前言生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 现在用四种方式来实现生产者消费者模型
什么是Java中的Lambda表达式和函数式接口？它们有何作用？.
07-14
在Java 8中引入了Lambda表达式和函数式接口。 Lambda表达式是一种简洁的语法，用于表示可传递的匿名函数。它可以用于替代使用匿名内部类的方式来实现接口的抽象方法。Lambda表达式的基本语法是：(参数列表) -> {函数体}。例如，`(x, y) -> x + y`表示一个接受两个参数并返回它们的和的Lambda表达式。 函数式接口是只包含一个抽象方法的接口。Java中的Lambda表达式可以与函数式接口一起使用，以提供一种更简洁、更灵活的方式来实现接口的功能。函数式接口可以使用`@FunctionalInterface`注解进行标记，以确保它只包含一个抽象方法。 Lambda表达式和函数式接口的作用包括： 1. 简化代码：Lambda表达式可以让代码更加简洁、易读，避免了繁琐的匿名内部类的写法。 2. 支持函数式编程：Lambda表达式使得Java可以支持函数式编程风格，可以将函数作为一等公民进行处理，如传递函数、返回函数等。 3. 并行处理：Lambda表达式可以与Java 8引入的Stream API一起使用，支持并行处理大数据集合，提高程序的性能。 4. 增强API：Java标准库中的许多接口和类都提供了接受函数式接口作为参数的方法，通过Lambda表达式可以更方便地使用这些API。 总之，Lambda表达式和函数式接口使得Java在语言层面上支持函数式编程范式，提高了代码的简洁性和灵活性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值