Java语言高级-05异常与多线程-第6节 Lambda表达式

最新推荐文章于 2024-06-03 12:44:17 发布
最新推荐文章于 2024-06-03 12:44:17 发布
阅读量73 收藏 1
点赞数
分类专栏： Java学习教程 文章标签： java spring 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37975179/article/details/127032578
版权

函数式编程思想概述
在这里插入图片描述
在这里插入图片描述
冗余的Runnable代码

package demo04;

/*
	使用实现Runnable接口的方式实现多线程程序
 */
public class Demo01Runnable {
	public static void main(String[] args) {
		//创建一个Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		//创建Thread类对象，构造方法中传递Runnable接口的实现类
		Thread t = new Thread(run);
		//调用start方法开启新线程，执行run方法
		t.start();
		
		//简化代码，使用匿名内部类，实现多线程程序
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		};
		new Thread(r).start();
		
		//简化代码
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		}).start();
	}
}


package demo04;

/*
	创建Runnable接口的实现类，重写Run方法，设置线程任务
	
 */
public class RunnableImpl implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"新的线程创建了");
	}
}

**编程思想转换 体验Lambda的更优 **

package demo04;

public class Demo02Lambda {
	public static void main(String[] args) {
		//使用匿名内部类的方式实现多线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		}).start();
		
		//使用Lambda表达式实现多线程
		new Thread(()-> {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		).start();
	}
}

Lambda的标准格式
在这里插入图片描述
在这里插入图片描述

package demo04;

/*
	Lambda表达式的标准格式：
		由三部分组成：
			一些参数
			一个箭头
			一段代码
		格式：
			(参数列表)->(一些重写方法的代码);
		解释说明格式：
			():接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔
			->:传递的意思，把参数传递给方法体{}
			{}：重写接口的抽象方法的方法体
 */
public class Demo02Lambda {
	public static void main(String[] args) {
		//使用匿名内部类的方式实现多线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		}).start();
		
		//使用Lambda表达式实现多线程
		new Thread(()-> {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		).start();
	}
}

Lambda表达式的无参数无返回值的方法

package demo04;


/*
	需求：
		给定一个厨子Cook接口，内含唯一的抽象方法makeFood,且无参数，无返回值
		使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样
 */
public class Demo01Cook {
	public static void main(String[] args) {
		//调用invokeCook方法，参数是Cook接口，传递Cook接口中的匿名内部类对象
		invokeCook(new Cook() {
			@Override
			public void makeFood() {
				System.out.println("吃饭了");
			}
		});
		
		//使用Lambda表达式，简化匿名内部类的书写
		invokeCook(()->{
				System.out.println("吃饭了");
			});
	}
	//定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
	public static void invokeCook(Cook cook) {
		cook.makeFood();
	}
}


package demo04;

/*
	定义一个厨子接口，内含唯一的抽象方法makefood
 */
public interface Cook {
	//定义无参数无返回值的方法makeFood
	public abstract void makeFood();
}

Lambda表达式有参数有返回值的方法

package demo04;

import java.util.Arrays;
import java.util.Comparator;

/*
	Lambda表达式有参数有返回值的练习
	需求：
		使用数组存储多个Person对象
		对数组中的Person对象使用Arrays的start方法通过年龄进行升序排序
 */
public class Demo01Arrays {
	public static void main(String[] args) {
		//使用数组存储多个Person对象
		Person[] arr = {
			new Person("柳岩",38),
			new Person("迪丽热巴",18),
			new Person("古力娜扎",19)
		};
		
		//对数组中的Person对象使用Arrays的start方法通过年龄进行升序排序
//		Arrays.sort(arr,new Comparator<Person>() {
//			@Override
//			public int compare(Person o1, Person o2) {
//				return o1.getAge()-o2.getAge();
//			}
//		});
		
		//使用lambda表达式，简化匿名内部类
		Arrays.sort(arr,(Person o1,Person o2)->{
			return o1.getAge()-o2.getAge();
		});
		
		//遍历数组
		for (Person p : arr) {
			System.out.println(p);
		}
	}
}


package demo04;

public class Person {

	private String name;
	private int age;
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

lambda表达式有参数有返回值的练习

package demo04;

/*
	lambda表达式有参数有返回值的练习
	需求：
		给定一个计算器calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
		使用lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
 */
public class Demo01Calculator {
	public static void main(String[] args) {
		//调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
		invokeCalc(10, 20, new Calculator() {
			@Override
			public int calc(int a, int b) {
				// TODO Auto-generated method stub
				return a+b;
			}
		});
		
		//使用lambda表达式简化匿名内部类的书写
		invokeCalc(120, 130, (int a,int b)->{
			return a+b;
		});
	}
	
	/*定义一个方法，
		参数传递两个int类型的整数
		参数传递Calculator接口
		方法内部调用Calculator中的方法计算两个整数的和
		
	 */
	public static void invokeCalc(int a,int b,Calculator c) {
		int sum = c.calc(a,b);
		System.out.println(sum);

	}
}


package demo04;

/*
	给定一个计算器calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
 */
public interface Calculator {
	//定义一个计算两个int整数和的方法并返回结果
	public abstract int calc(int a,int b);
}

lambda省略格式 lambda使用前
在这里插入图片描述

package demo04;

import java.util.ArrayList;

/*
	lambda表达式：是可推导，可以省略
	凡是根据上下文推到出来的内容，都可以省略书写
	可以省略的内容：
		1、(参数列表)：括号中参数列表的数据类型，可以省略不写
		2、(参数列表)：括号中的参数如果只有一个，那么类型和()都可以省略
		3、(一些代码)：如果{}中过的代码只有一行，无论是否有返回值，都可以省略({},return,分号)
			注意：要省略{}，return，分号必须一起省略
 */
public class Demo01ArrayList {
	public static void main(String[] args) {
		//JDK1.7版本之前，创建集合对象必须把前后的泛型都写上
		ArrayList<String> list01 = new ArrayList<String>();
		
		//JDK1.7版本之后，=号后边的泛型可以省略，后边的泛型可以根据前边的泛型推导出来
		ArrayList<String> list02 = new ArrayList<String>();
		
	}
}


package demo04;

/*
	Lambda表达式的标准格式：
		由三部分组成：
			一些参数
			一个箭头
			一段代码
		格式：
			(参数列表)->(一些重写方法的代码);
		解释说明格式：
			():接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔
			->:传递的意思，把参数传递给方法体{}
			{}：重写接口的抽象方法的方法体
 */
public class Demo02Lambda {
	public static void main(String[] args) {
		//使用匿名内部类的方式实现多线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		}).start();
		
		//使用Lambda表达式实现多线程
		new Thread(()-> {
				System.out.println(Thread.currentThread().getName()+"新的线程创建了");
			}
		).start();
		
		//优化省略lanbda
		new Thread(()->System.out.println(Thread.currentThread().getName()+"新的线程创建了")).start();
	
	}
}


package demo04;


/*
	需求：
		给定一个厨子Cook接口，内含唯一的抽象方法makeFood,且无参数，无返回值
		使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样
 */
public class Demo01Cook {
	public static void main(String[] args) {
		//调用invokeCook方法，参数是Cook接口，传递Cook接口中的匿名内部类对象
		invokeCook(new Cook() {
			@Override
			public void makeFood() {
				System.out.println("吃饭了");
			}
		});
		
		//使用Lambda表达式，简化匿名内部类的书写
		invokeCook(()->{
			System.out.println("吃饭了");
		});
		
		//优化省略lambda
		invokeCook(()->System.out.println("吃饭了"));
	}
	//定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
	public static void invokeCook(Cook cook) {
		cook.makeFood();
	}
}


package demo04;

import java.util.Arrays;
import java.util.Comparator;

/*
	Lambda表达式有参数有返回值的练习
	需求：
		使用数组存储多个Person对象
		对数组中的Person对象使用Arrays的start方法通过年龄进行升序排序
 */
public class Demo01Arrays {
	public static void main(String[] args) {
		//使用数组存储多个Person对象
		Person[] arr = {
			new Person("柳岩",38),
			new Person("迪丽热巴",18),
			new Person("古力娜扎",19)
		};
		
		//对数组中的Person对象使用Arrays的start方法通过年龄进行升序排序
//		Arrays.sort(arr,new Comparator<Person>() {
//			@Override
//			public int compare(Person o1, Person o2) {
//				return o1.getAge()-o2.getAge();
//			}
//		});
		
		//使用lambda表达式，简化匿名内部类
		Arrays.sort(arr,(Person o1,Person o2)->{
			return o1.getAge()-o2.getAge();
		});
		
		//优化省略lambda
		Arrays.sort(arr,(o1, o2)-> o1.getAge()-o2.getAge());
		
		//遍历数组
		for (Person p : arr) {
			System.out.println(p);
		}
	}
}


package demo04;

/*
	lambda表达式有参数有返回值的练习
	需求：
		给定一个计算器calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
		使用lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
 */
public class Demo01Calculator {
	public static void main(String[] args) {
		//调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
		invokeCalc(10, 20, new Calculator() {
			@Override
			public int calc(int a, int b) {
				// TODO Auto-generated method stub
				return a+b;
			}
		});
		
		//使用lambda表达式简化匿名内部类的书写
		invokeCalc(120, 130, (int a,int b)->{
			return a+b;
		});
		
		//优化省略lambda
		invokeCalc(120, 130, (a, b)-> a+b);
	}
	
	/*定义一个方法，
		参数传递两个int类型的整数
		参数传递Calculator接口
		方法内部调用Calculator中的方法计算两个整数的和
	 */
	public static void invokeCalc(int a,int b,Calculator c) {
		int sum = c.calc(a,b);
		System.out.println(sum);
	}
	
}
朗朗乾坤光风霁月
关注
专栏目录
（Java高级教程）第一章Java多线程基础-第一节：多线程概念和Java中创建线程的方式
快乐江湖的博客
11-06 285
线程：关于进程和线程的概念这里就不再重复了，具体可见(王道408考研操作系统)第二章进程管理-第一节5：线程的概念(王道408考研操作系统)第二章进程管理-第一节6：线程的实现方式和多线程模型要想进行下一步学习，你至少要清楚以下概念明白计算机的基本工作流程（冯诺依曼，寄存器、指令等概念）什么是进程，如何理解进程并行和并发进程PCB的概念进程调度与通信的概念什么是线程、为什么要引入线程进程和线程的区别线程调度用户级线程和内核级线程多线程的概念…
Java学习笔记②⑥(函数式编程思想概述、冗余的Runnable代码、编程思想转换、Lambda表达式)
weixin_45994391的博客
04-30 261
一、函数式编程思想概述 二、冗余的Runnable代码 package day03.Demo06; //使用实现了Runnable接口的方式实现多线程程序 public class Demo06Runnable { public static void main(String[] args) { //创建Runnable接口的实现类对象 RunnableImpl run = new RunnableImpl(); //创建Thread类对象，构造方
java -- 函数式编程
weixin_44966435的博客
04-20 1053
函数式编程
Lambda表达式简化Runnable接口的匿名内部类写法。
linggle的博客
11-28 6320
Lambda表达式简化Runnable接口的匿名内部类写法。 点进去Lambda接口中去发现，只有一个抽象方法， 并且有@FunctionalInterface(函数式接口的注解)。 有了这个注解的接口就是函数式接口，这个有且仅有一个接口 */ public class ThreadPoolDemo03 { public static v...
java8中的函数式编程（Runnable、Comparator和FileFilter接口）
weixin_43871333的博客
05-16 1482
1.lambda表达式（函数式编程） 当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable接口来定义任务内容，并使用java.lang.Thread类来启动该线程。 代码如下： 方法一 //自定义一个线程类Thread2 public class TreadT2 implements Runnable { @Override public void run() { f...
04、Java 8 - Runnable Lambda 表达式
qq_33291299的博客
01-04 279
本章节我们重点来讲讲 Java 8 中的 Runnable Lambda 表达式。众所周知，Java 8 中的 Runable 和 Callable 两个接口都添加了 @FunctionalInterface 注解，因此我们可以直接使用 Lambda 表达式来代替它们的 run() 和 call() 方法
Java学习---异常与多线程（一）
m0_51994031的博客
04-18 236
异常与多线程异常线程实现方式线程同步机制等待唤醒机制线程池Lambda表达式 异常 异常就是不正常的意思，指在程序执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。 Java本身就是面向对象的编程语言，因此不难得出，异常本身就是一个类，产生异常就是创建异常对象并抛出了一个异常对象。 注意：异常指的并不是语法错误。语法错误，编译不通过，不会产生字节码文件，更不会运行。 异常体系： Throwable类在java.lang包下，Throwable是所有错误或异常的超类（父类） 错误了就必须重写代码
Java基础-7（多线程，线程安全，线程状态，Lambda表达式）
q172395505的博客
07-23 297
38.多线程 并发∶指两个或多个事件在同一个时间段内发生。 并行指两个或多个事件在同一时刻发生（同时发生)。 线程和进程 进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个 进程;进程也是程序的一次执行过程，是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、 运行到消亡的过程。 线程︰线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中 是可以有多个线程的，这个应用程序也可以称之为多线程程序。 简而言之:
JAVA Lambda表达式详细讲解
康康要加油的博客
01-24 1379
JAVA Lambda表达式详细讲解
Java基础--Lambda表达式和Stream流式处理
weixin_33407107的博客
05-27 437
什么是Lambda表达式 jdk8开始支持Lambda表达式，用来让程序编写更优雅 利用Lambda可以更简洁的实现匿名内部类和函数声明与调用 基于Lambda提供stream流式处理极大简化了对集合的操作 List<String> names=Arrays.asList("peter","anna","mike","john"); //实现集合排序 Collections.sort(names,new Comparator<String>(){ @Override
Java8 Runnable Lambda 表达式
weixin_45345143的博客
03-08 439
我们重点来讲讲 Java 8 中的RunnableLambda 表达式。众所周知，Java 8 中的Runable和Callable两个接口都添加了注解，因此我们可以直接使用 Lambda 表达式来代替它们的run()和call()方法Java 8 开始支持 Lambda 表达式，所以，好像，一夜间，所有添加了注解的方法都可以使用 Lambda 表达式来创建实例，Runnable也不例外，我们可以直接使用一个 Lambda 表达式来创建它的实例运行结果输出为。
65.JAVA编程思想——关于Runnable
热门推荐
badman250的专栏
05-08 3万+
65.JAVA编程思想——关于Runnable 在早些时候，曾建议大家在将一个程序片或主Frame 当作Runnable 的实现形式之前，一定要好好地想一想。若采用那种方式，就只能在自己的程序中使用其中的一个线程。这便限制了灵活性，一旦需要用到属于那种类型的多个线程，就会遇到不必要的麻烦。 当然，如果必须从一个类继承，而且想使类具有线程处理能力，则Runnable 是一种正确的方案。最后一个例
java8新特性：lambda表达式,使用lambda表达式实现Runnable接口
weixin_44673447的博客
03-24 3485
java8新特性：lambda表达式,使用lambda表达式实现Runnable接口 1.使用lambda表达式实现interface接口 1.1、当一个接口只有一个方法时，可以使用lambda表达式实现这个接口。 1.2、当方法中只有一条语句时，可以不写大括号 1.3、方法中超过一条语句时，需要写大括号 interface Animal{ void play(); } Animal animal = ()->{System.out.print("hello");}//当一个接口只有一个方法时，可以
Java 函数式编程 详细介绍
射手座轩木酱的代码天地~
05-13 3194
在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。下面我们做一个初探。
【Java 8 新特性】Java 8 Runnable和Callable使用Lambda表达式示例(带参数)
猫巳的博客
05-18 6842
Java 8 Runnable和Callable使用Lambda表达式示例Java 8 Runnable Lambda示例(带参数)Java 8 Callable Lambda示例(带参数)参考文献 在Java 8中，Runnable和Callable两个接口均已通过@FunctionalInterface进行注释。 我们可以使用lambda表达式实现run()和call()方法。 在此页面上，我们还将提供如何将参数传递给Runnable和Callable方法。 Java 8 Runnable Lambda
多线程 lambda练习
m0_49545872的博客
03-03 158
1.推导lambda package com.java.demo01; //推导lambda表达式 public class TestLambda1 { //静态内部类 static class Like1 implements Ilike { @Override public void lambda() { System.out.println("i like lambda1"); } } pu
Java线程的两种实现方式（Rundable接口和lambda)
m0_62448751的博客
04-17 276
【代码】Java线程的两种实现方式（Rundable接口和lambda)
启动一个线程Thread是用run()还是start()?
不见风雨怎能见彩虹
11-24 8485
启动一个线程是调用start()方法，使线程就绪状态，以后可以被jvm调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。 实现并启动线程有两种方法： 1、写一个类继承自Thread类，重写run方法。用start方法启动线程 2、写一个类实现Runnable接口，实现run方法。用new Thread(Runnable target).start()方法来...
Java 8 新特性： Lambda 表达式
最新发布
qq_33326733的博客
06-03 869
我们可以自定义一个函数式接口，并使用 Lambda 表达式来实现它。lambdaInterfaceDemo(() -> System.out.println("自定义函数式接口"));// 函数式接口参数i.f();
Java语言特性：模块、流、线程、I/O与lambda表达式（2nd Edition）
3. **线程（Threads）**：Java一直以其强大的多线程支持而闻名。在本书中，读者将深入理解如何创建和管理线程，包括同步机制（如`synchronized`关键字、`wait()`, `notify()`方法和`Lock`接口）、并发工具类（如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值