136.JDk8增加的新特性Lambda,简化线程

最新推荐文章于 2021-08-26 18:24:28 发布
最新推荐文章于 2021-08-26 18:24:28 发布
阅读量260 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43808700/article/details/108830686
版权

希腊字母表中排序第十一位的字母，英文是Lambda，可以避免匿名内部类定义过多，其实质属于函数式编程的概念

我们对 133.实现Runnable接口实现多线程文章中实现Runnable的代码进行改造
首先我们可以给要实现多线程的类提供一个实现Runnable了接口的内部类，来实现多线程
package yzy.cn;

public class lambdaThread01{
	/*
	 *  我们可以给要实现多线程的类提供一个实现Runnable了接口的内部类，来实现多线程
	 */
	
	//静态内部类（外部类不使用，内部类就不会加载）
	static class Test implements Runnable{
		public void run() {
			for(int i=0; i<20; ++i)
				System.out.println("singing");
		}
	}
	public static void main(String[] args) {
		new Thread(new Test()).start();
	}
}

静态内部类好处就是：它的外部类不使用，内部类就不会加载1

我们继续对只使用一次的静态类进行改造，将内部类放到main里,作为方法内部类 2使用
package yzy.cn;

public class lambdaThread02 {
	public static void main(String[] args) {
		class Test implements Runnable{
			public void run() {
				for(int i=0; i<20; ++i)
					System.out.println("singing");
			}
		}
		
		new Thread(new Test()).start();
	}
}
继续改造成匿名内部类

改造成匿名内部类 3

package yzy.cn;

public class lambdaThread03 {
	public static void main(String[] args) {
		/*
		 * 在new Thread中扔进去一个new 接口加花括号引起来的类体
		 */
		new Thread(new Runnable() {
			public void run() {
				for(int i=0; i<20; ++i)
					System.out.println("singing");
			}
		}).start();
	}
}
匿名内部类只有实现Runnable接口的run方法，因此使用jdk8的lambda表达式4
package yzy.cn;

public class lambdaThread04 {
	public static void main(String[] args) {
		/*
		 * 使用jdk8的lambda表达式继续简化，只需要关注线程体的run方法就行
		 * 只需要注意参数和函数内部的具体实现就行，适用于简单的线程体
		 */
		new Thread(()-> {
				for(int i=0; i<20; ++i)
					System.out.println("singing");
		}).start();
	}
}
再写一个接口和实现类对以上改造过程进行复习
先写一个接口和实现类
package yzy.cn;

public class lambdaTest {
	public static void main(String[] args) {
		iLike like = new Like();
		like.lambda();
	}
}
interface iLike{
	void lambda();
}
class Like implements iLike{
	public void lambda() {
		System.out.println("i like lambda!");
	}
}
静态内部类
package yzy.cn;

public class lambdaTest {
	static class Like implements iLike{
		public void lambda() {
			System.out.println("i like lambda!");
		}
	}
	public static void main(String[] args) {
		iLike like = new Like();
		like.lambda();
	}
}
interface iLike{
	void lambda();
}
方法内部类
package yzy.cn;

public class lambdaTest {
	public static void main(String[] args) {
		//方法内部类
		class Like implements iLike{
			public void lambda() {
				System.out.println("i like lambda!");
			}
		}
		
		iLike like = new Like();
		like.lambda();
	}
}
interface iLike{
	void lambda();
}
匿名内部类
package yzy.cn;

public class lambdaTest {
	public static void main(String[] args) {
		//借助接口实现匿名内部类
		iLike like = new iLike() {
			public void lambda() {
				System.out.println("i like lambda!");
			}
		};
		like.lambda();
	}
}
interface iLike{
	void lambda();
}
lambda
package yzy.cn;

public class lambdaTest {
	public static void main(String[] args) {
		//lambda
		iLike like = ()-> {
				System.out.println("i like lambda!");
			};
		like.lambda();
	}
}
interface iLike{
	void lambda();
}
再写一个接口和有参数的实现类对以上改造过程进行深究
package yzy.cn;

public class lambdaTest02 {
	public static void main(String[] args) {
		iLove love = new Love();
		love.lambda(10);
	}
}
interface iLove{
	void lambda(int a);
}
class Love implements iLove{
	public void lambda(int a) {
		System.out.println("The parameter is " + a);
	}
}
用Lambda表达式改进
package yzy.cn;

public class lambdaTest02 {
	public static void main(String[] args) {
		//lambda表达式，只需要注意具体实现体
		iLove love = (int a)-> {
			System.out.println("The parameter is " + a);
		};
		love.lambda(10);
	}
}
继续改进，lambda表达式的参数类型也可以省略
package yzy.cn;

public class lambdaTest02 {
	public static void main(String[] args) {
		//lambda表达式，只需要注意具体实现体
		iLove love = (a)-> {
			System.out.println("The parameter is " + a);
		};
		love.lambda(10);
	}
}
interface iLove{
	void lambda(int a);
}
class Love implements iLove{
	public void lambda(int a) {
		System.out.println("The parameter is " + a);
	}
}
继续改进，lanbda表达式只有一个参数的时候，括号也可以省略
package yzy.cn;

public class lambdaTest02 {
	public static void main(String[] args) {
		//lambda表达式，只需要注意具体实现体
		iLove love = a-> {
			System.out.println("The parameter is " + a);
		};
		love.lambda(10);
	}
}
interface iLove{
	void lambda(int a);
}
class Love implements iLove{
	public void lambda(int a) {
		System.out.println("The parameter is " + a);
	}
}
函数题只有一行，就不需要大括号
package yzy.cn;

public class lambdaTest02 {
	public static void main(String[] args) {
		//lambda表达式，只需要注意具体实现体
		iLove love = a->System.out.println("The parameter is " + a);
		love.lambda(10);
	}
}
interface iLove{
	void lambda(int a);
}
class Love implements iLove{
	public void lambda(int a) {
		System.out.println("The parameter is " + a);
	}
}
再练习一个带有返回值的静态代理模式
package yzy.cn;

public class lambdaTest03 {
	public static void main(String[] args) {
		iInterest iIn = new Interest();
		System.out.println(iIn.lambda(10, 20));
	}
}

interface iInterest{
	int lambda(int a, int b);
}

class Interest implements iInterest{
	public int lambda(int a, int b) {
		System.out.println("The parameter is " + a + " and " + b);
		return a+b;
	}	
}
用lambda改进
package yzy.cn;

public class lambdaTest03 {
	public static void main(String[] args) {
		iInterest iIn = (int a, int b)-> {
			System.out.println("The parameter is " + a + " and " + b);
			return a+b;
		};
		System.out.println(iIn.lambda(10, 20));
		
	}
}

interface iInterest{
	int lambda(int a, int b);
}

class Interest implements iInterest{
	public int lambda(int a, int b) {
		System.out.println("The parameter is " + a + " and " + b);
		return a+b;
	}	
}
省略参数类型
package yzy.cn;

public class lambdaTest03 {
	public static void main(String[] args) {
		iInterest iIn = (a, b)-> {
			System.out.println("The parameter is " + a + " and " + b);
			return a+b;
		};
		System.out.println(iIn.lambda(10, 20));
		
	}
}

interface iInterest{
	int lambda(int a, int b);
}

class Interest implements iInterest{
	public int lambda(int a, int b) {
		System.out.println("The parameter is " + a + " and " + b);
		return a+b;
	}	
}

如果函数体只有返回值：return a+b;一句，就可以简化如下：

iInterest iIn = (a, b)->  a+b;
最终 133.实现Runnable接口实现多线程 中的coding、singing多线程就可以利用lambda简化至此：
package yzy.cn;

public class lambdaTest04 {
	public static void main(String[] args) {
		new Thread(()->System.out.println("singing")
				).start();
		
		new Thread(()->{
			for(int i=0; i<10; ++i)
				System.out.println("coding");
		}).start();
		
	}
}

  1. 编译 ↩︎

  2. 局部内部类 ↩︎

  3. 必须借助接口或者父类 ↩︎

  4. 简化简单的线程类 ↩︎

云疏不知数
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jdk8之lambda表达式的使用(一)
小金子的专栏
12-20 6353
Jdk出来也已经很久了,一直没有时间去了解,今天趁着有空,小金子带你们使用一下Jdk中最让我感兴趣的部分:lambda表达式,使用这个可以很大程度上减少代码量,并且让代码看上去更舒心!废话就不多说啦,直接带你们使用吧! 1.第一次来点简单的: 下面是一个接口,相信大家都看得懂,是不是和Runnable接口很像呢？确实,其实定义这个接口的目的就是为了获取Run方法中线程要执行的代码.所以这里我们
JDK8新特性之Lambda表达式
不能说的秘密的博客
10-28 2730
第一次是接触Lambda表达式是在TypeScript中(javaScript的超集中)，当时是为了让TypeScript的this方法外而不是本方法内所使用的。使用过后突然想到Lambda不是JDK8的重量级新特性么？于是感觉查阅相关资料并记录下来
Java-JDK8之后的Lambda表达式
weixin_46505818的博客
07-09 101
Lambda表达式是java jdk8之后的一个新特性，最直观的作用是可以使得代码简洁，使用最多的就是接口的实现这一块，可以操作数组，集合等，尤其是在集合的遍历和其他集合操作过程中，可以极大优化代码的结构。接下来我就直接介绍Lambda的语法再简单的写一个入门案例，旨在复习一天所学内容，可以更好的理解函数式编程，以及对接口实现的方法有更加深刻地认识！ Lambda介绍 首先，我们可以思考一个问题，我们是否可以将一个代码块例如 public void doSomeShit(String s){ Syst.
JDK8 Lambda表达式
曹举的个人博客
12-01 616
一、什么是函数式编程和什么是lambda表达式 在JDK8之前，Java是不⽀持函数式编程的。 所谓的函数编程：即可理解是将⼀个函数（也称为“行为”）作为⼀个参数进⾏传递， ⾯向对象编程是对数据的抽象（各种各样的POJO类），而函数式编程则是对行为的抽象（将⾏为作为⼀个参数进行传递） Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤...
jdk8 新特性 lambda表达式---学习笔记
Huangwen的博客
08-08 438
转自：JDK1.8 十大新特性详解 前言：“Java is still not dead—and people are starting to figure that out.” jdk8已经出来很久了，但从来没有仔细研究过他到底带来了哪些改变，自从进入了新公司，发现公司代码中用到了很多jdk8的新特性，无奈，我居然看不懂，所以不得不去学习这些特性，说来也是惭愧。 一、Lambda 表达式 ...
day22_JDK8新特性.pdf
11-02
JDK8的许多新特性，包括Lambda表达式和Stream API，都是通过JEPs提出的。 总的来说，JDK8的这些新特性显著改善了Java的开发体验，使得Java在现代软件开发中保持了竞争力。Lambda表达式的引入让Java具备了函数式编程...
JDK8新特性（pdf版）
06-26
JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数式接口、方法引用、Stream API、Optional、新时间日期API等。 一、Java发展历史 Java的发展历史可以追溯到1991年，Sun公司成立了一个称为...
jdk8 jdk9 jdk11等的新特性
12-22
以下是对JDK 8、9、11等版本主要新特性的详细说明： ### JDK 8 新特性 1. **函数式接口**： Java 8 引入了函数式接口的概念，允许接口只有一个抽象方法。这使得接口可以直接被当作函数调用。`@Functional...
jdk8安装包（含windows和linux版本）.zip
最新发布
04-18
JDK8引入了许多重要的新特性，其中最显著的是Lambda表达式，它简化了处理函数式编程和集合的操作。Stream API也是JDK8的一大亮点，它允许对集合进行高效、声明式的操作，提高了代码的可读性和简洁性。此外，新版本还...
JDK8新特性.pdf
03-09
总的来说，Java 8的这些新特性推动了Java语言的现代化，使得Java更加适应函数式编程和并发编程的需求，同时也提高了开发效率和代码质量。对于Java开发者来说，理解和掌握这些新特性至关重要。无论是在校学生还是在职...
创建线程的方式三（jdk8-lambda）
qq_29257691的博客
10-02 1600
public class lambdaTest6 { public static void main(String[] args) { new Thread(()->{ for(int i=0;i<100;i++) { System.out.println("一边学习lambda"); ...
java8中的Lambda
liming0025的专栏
07-01 1583
jdk8中提供了几个新特性，其中一个比较受瞩目的就是Lambda表达式。 Lambda也是就函数式编程，主要替代了之前版本的匿名内部类的的实现。下面看一个例子： 在jdk8之前，如果想实现一个线程，可以使用如下方式： 使用Lambda表达式之后，我们可以这些编写： 简单的一句话，代替了之前看似复杂的实现，至于所说的可读性，如果明白这么是怎么回事，那么可读性提高，不明白，就没有所谓的可读性。 Lambda语法 从上面的例子可以看出来，lambda语法分为2部分，使用"->"进行分割，
jdk8新特性（Lambda表达式）结合spring 线程池，一行代码实现多线程
y173447104的博客
11-16 3242
1.配置spring 线程池 @Configuration @EnableAsync @ConfigurationProperties(prefix="threadpool") public class ExecutePoolConfiguration { @Value("${threadpool.core-pool-size}") private int corePoolS...
Java多线程（4）：lambda简化线程
weixin_42701161的博客
02-05 222
一、静态内部类、局部内部类、匿名内部类（定义的线程只使用一次） 1、静态内部类：嵌套在另一个类的里面，直接实例化内部的类，外面的类不编译 public class LambdaThread { static class Test implements Runnable{ public void run() { for(int i=0;i<20;i++) { ...
jdk8新特性-Lambda表达式及函数式接口
攻城老湿的博客
08-26 217
在多线程方面，Lambda表达式的使用 不使用Lambda表达式的情况下，开启多线程的方式 /* 测试：开启多线程，打印数据 结论：不使用函数式编程带来冗余 */ public class Demo01Runnable { public static void main(String[] args) { //使用Runnable的实现类，完成方法调用 ...
java lambda线程简化
u014248032的博客
06-13 1759
1 静态内部类 package study_02; public class LamdaThread { //静态内部类 static class Test implements Runnable{ public void run() { for (int i = 0; i < 20; i++) { System.out.println("coding....."...
jdk1.8 新特性之 lambda表达式
多一份贡献,多一份环保
04-23 1万+
我们首先看一个java实现多线程的lambda表达式的例子常规Runnable runnable = new Runnable(){ @Override public void run() { System.out.println("多线程"); }};lambda形式Runnable runna
Java使用jdk1.8新特性lambda表达式创建线程
热门推荐
吴名氏的博客
06-26 17万+
这是代码： package test; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub //正常的方式 new Thread(new Runnable() { @Override public void run(...
lambda表达式简化线程
lzy970613的博客
03-07 766
1.lambda作用主要是简化代码块，当只需要使用一次实现类中的方法时可以 使用lambda 2在简化线程当中的使用 public class LambdaTest03 { public static void main(String[] args) { new Thread(()-> { //实现runnable接口的实现类 System.out.println("...
Lambda表达式与JDK8新特性详解
本资源主要讨论了JDK 8的新特性，特别是Lambda表达式、函数式编程思想以及Stream流的相关内容。首先，介绍了OpenJDK和Oracle JDK的关系，指出OpenJDK是Sun公司在2006年Java平台开源后的产物，由Java社区支持，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值