JDK1.8新特性（一）

最新推荐文章于 2023-07-04 13:46:59 发布
最新推荐文章于 2023-07-04 13:46:59 发布
阅读量275 收藏
点赞数
分类专栏： java 后端 文章标签： java jdk8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nqmysbd/article/details/88724688
版权

官方文档
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
教程
http://www.runoob.com/java/java8-new-features.html

Lambda表达式

//示例：集合排序（函数体只有一行不需大括号）
List<String> strList = Arrays.asList( "d", "a", "b" );
		strList.sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
		strList.forEach(( String e ) -> System.out.println( e ));

//示例：遍历集合（函数体有多行代码需大括号）
Arrays.asList( "a", "b", "d" ).forEach(( String e ) -> {
		    System.out.println( e );
		    System.out.println( e );
		} );

方法引用

方法引用

  1. 方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致
  2. 若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

示例：对象的引用 :: 实例方法名

//对象的引用 :: 实例方法名
@Test
	public void objectTest(){
		PrintStream ps = System.out;
		Consumer<String> con = (str) -> ps.println(str);
		con.accept("Hello World！");
		
		System.out.println("--------------------------------");
		
		Consumer<String> con2 = ps::println;
		con2.accept("Hello Java8！");
		
		Consumer<String> con3 = System.out::println;
	}

示例：类名 :: 静态方法名

//类名 :: 静态方法名
	@Test
	public void classTest(){
		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
		
		System.out.println("-------------------------------------");
		
		Comparator<Integer> com2 = Integer::compare;
	}

示例：类名 :: 实例方法名

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

	public Employee(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}

}

//类名 :: 实例方法名

	@Test
	public void classInstanceTest(){
		BiPredicate<String, String> bp = (x, y) -> x.equals(y);
		System.out.println(bp.test("abcde", "abcde"));
		
		System.out.println("-----------------------------------------");
		
		BiPredicate<String, String> bp2 = String::equals;
		System.out.println(bp2.test("abc", "abc"));
		
		System.out.println("-----------------------------------------");
		
		
		Function<Employee, String> fun = (e) -> e.show();
		System.out.println(fun.apply(new Employee()));
		
		System.out.println("-----------------------------------------");
		
		Function<Employee, String> fun2 = Employee::show;
		System.out.println(fun2.apply(new Employee()));
		
	}

构造器引用

构造器引用

构造器的参数列表，需要与函数式接口中参数列表保持一致

示例：引用无参构造器
public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

	public Employee(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}

}

//构造器引用
	@Test
	public void defaultConstructorTest(){
		Function<String, Employee> fun = Employee::new;
		
		BiFunction<String, Integer, Employee> fun2 = Employee::new;
	}

示例：引用有参构造器
public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

	public Employee(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}

}

@Test
	public void constructorTest(){
		Supplier<Employee> sup = () -> new Employee();
		System.out.println(sup.get());
		
		System.out.println("------------------------------------");
		
		Supplier<Employee> sup2 = Employee::new;
		System.out.println(sup2.get());
	}

数组引用

示例：字符串数组引用

//数组引用
	@Test
	public void arrayTest(){
		Function<Integer, String[]> fun = (args) -> new String[args];
		String[] strs = fun.apply(10);
		System.out.println(strs.length);
		
		System.out.println("--------------------------");
		
		Function<Integer, Employee[]> fun2 = Employee[] :: new;
		Employee[] emps = fun2.apply(20);
		System.out.println(emps.length);
	}

函数式接口

示例：消费型接口

//Consumer<T> 消费型接口 :
@Test
public void consumerTest(){
	happy(10000, (m) -> System.out.println("每次消费：" + m + "元"));
} 

public void happy(double money, Consumer<Double> con){
	con.accept(money);
}

示例：供给型接口

//Supplier<T> 供给型接口 :
	@Test
	public void supplierTest(){
		List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
		
		for (Integer num : numList) {
			System.out.println(num);
		}
	}
	
	//需求：产生指定个数的整数，并放入集合中
	public List<Integer> getNumList(int num, Supplier<Integer> sup){
		List<Integer> list = new ArrayList<>();
		
		for (int i = 0; i < num; i++) {
			Integer n = sup.get();
			list.add(n);
		}
		
		return list;
	}

示例：函数型接口

//Function<T, R> 函数型接口：
	@Test
	public void functionTest(){
		String newStr = strHandler("\t\t\t 呵呵   ", (str) -> str.trim());
		System.out.println(newStr);
		
		String subStr = strHandler("呵呵", (str) -> str.substring(2, 5));
		System.out.println(subStr);
	}
	
	//需求：用于处理字符串
	public String strHandler(String str, Function<String, String> fun){
		return fun.apply(str);
	}

示例：断言型接口

//Predicate<T> 断言型接口：
	@Test
	public void predicateTest(){
		List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
		List<String> strList = filterStr(list, (s) -> s.length() > 3);
		
		for (String str : strList) {
			System.out.println(str);
		}
	}
	
	//需求：将满足条件的字符串，放入集合中
	public List<String> filterStr(List<String> list, Predicate<String> pre){
		List<String> strList = new ArrayList<>();
		
		for (String str : list) {
			if(pre.test(str)){
				strList.add(str);
			}
		}
		
		return strList;
	}
Lambda&Stream
m0_63158445的博客
02-24 853
Lambda&Stream - 能够掌握Lambda表达式的标准格式与省略格式(重点) 作用:简化函数式接口的匿名内部类 ()->{} (参数)->{重写接口中的抽象方法的方法体} (int a,int b)->{}==>省略数据类型 (a,b)->{} (int a)->{}==>省略数据类型 a->{} a->{只有一行代码}==>a->代码(return ; {} 一起省略) - 能够通过集合、映射或数组方式
lambda与Stream的 用法
小邯韩的博客
03-25 225
package org.jeecg.modules.quartz.job; import io.swagger.models.auth.In; import java.util.*; import java.util.function.BiPredicate; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; import java.uti
JAVA8之lambda表达式详解，及stream中的lambda使用
热门推荐
凤歌
02-26 4万+
1.什么是lambda表达式？ 2.lambda表达式用来干什么的？ 3.lambda表达式的优缺点？ 4.lambda表达式的使用场景？ 5.lambda只是有个语法糖吗？ 6.stream和lambda的关系 7.stream的作用 8.stream的使用
Lambda.Stream使用
红桃∩
07-02 280
目录实体类测试Lambda.Stream输出结果 实体类 @Data public class StreamTest { private Integer id; private Integer age; private String name; public StreamTest(Integer id, Integer age, String name) { this.id = id; this.age = age; this.name = name; } }
lambda和stream
十月
06-27 3431
lambda表达式 Java8引入了lambda表达式，在其他语言中，比如python、swift都支持lambda表达式，这个特性用起来也非常方便和简洁。 先来看lambda表达式的语法： () -> {} () : 括号就是接口方法的括号，接口方法如果有参数，也需要写参数。只有一个参数时，括号可以省略。 -> : 分割形参列表与函数体的。 {} : 如果代码体只有一行代码就可以省...
Lambda表达式与Stream流的使用
New_Project
03-10 336
Lambda表达式与Stream流的使用 来源: https://www.yuque.com/pig4cloud/pig/yewg8z stream流 https://www.cnblogs.com/haixiang/p/11029639.html lambda表达式 目录Lambda表达式与Stream流的使用Lambda表达式lambda表达式引用Java 8中的常用函数式接口Stream流使用概念特点操作种类使用创建流使用api方法使用Arrays.stream
jdk1.8新特性.doc
04-01
JDK1.8引入了许多重要的新特性，极大地提升了Java编程的效率和性能。以下是这些特性的详细介绍： 1、**Lambda表达式**： Lambda表达式是JDK1.8的一个重大改进，它允许开发者以更简洁的方式传递代码块。在上述示例中...
jdk1.8-331 java开发环境 jdk1.8版本
最新发布
12-09
JDK1.8-331指的是Java开发工具包（Java Development Kit）的1.8版本的第331次更新。JDK是用于开发Java应用程序的基础工具集，提供了编译器（javac）、运行环境（Java Runtime Environment，JRE）和一些基本的类库。...
jdk1.8.031 jdk1.8
10-22
JDK 1.8在Java历史上是一个重要的里程碑，它引入了大量新特性，包括Lambda表达式、新的日期时间API、Streams API等。 3. JDK 1.8的压缩包包含了多个文件和文件夹，每个都有其特定的作用。例如，COPYRIGHT文件包含了...
尚硅谷JDK1.8 新特性 培训PPT
05-15
视频教程地址：http://www.gulixueyuan.com/course/56
JDK1.8中文文档 JDK1.8中文 jkd8中文文档 JDK中文版
07-15
首先，JDK1.8最重要的新特性之一就是Lambda表达式。Lambda表达式是函数式编程的核心概念，它允许将函数作为一个值传递，简化了代码并提高了可读性。通过这种方式，开发者可以更方便地处理集合数据和编写多线程程序。...
JAVA8新特性Lambda表达式、Stream使用
11-19
需要环境：JDK8 下载下来后 直接导入IDE工具中，运行TestLambda、TestLambda2、TestLambda3、PracticeLambda、TestStream中的main方法就可以看见结果
Java Lambda Stream 特性 详解
TWW
04-08 959
Java Stream/Lambda 表达式 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 部分参考博客: https://www.cnblogs.com/song27/p/7697713.html ...
Lambda 和 Stream
m0_63660547的博客
07-04 500
Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。Lambda 表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。1.3表达式的结构Lambda 表达式可以具有零个，一个或多个参数。可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。
java Lambda表达式 Stream
chinusyan的专栏
11-11 628
1、函数式编程思想概述 面向对象编程思想 面向对象强调的是对象 , “必须通过对象的形式来做事情”，相对来讲比较复杂,有时候我们只是为了做某件事情而不得不创建一个对象 , 例如线程执行任务,我们不得不创建一个实现Runnable接口对象,但我们真正希望的是将run方法中的代码传递给线程对象执行 函数编程思想 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是
stream里lambda的使用
weixin_44716359的博客
08-27 190
匿名内部类 适用于那些只需要使用一次的类，例如现在存在一个接口，该接口里的方法只会被使用一次，按传统的做法就是专门写一个实现类来重写接口里的方法，这时会显得过于复杂且会生成这个类的.class文件；通过匿名内部类就能简化编程且不会生成.class文件 基础语法 new 需要实现的接口() | 父类构造器() { //需要实现的方法或重载父类的方法 } public class HelloWorld { static void info(Programmer programm
Lambda表达式&stream流
qq_56047419的博客
04-11 3074
一、Lambda表达式 1.Lambda表达式出现的背景; 我们想要把某些功能传递给某个方法，总要去写匿名类,就还是复杂了，因为其核心部分只是里面的函数表达式，于是Java 8 增加了一个语言级的新特性，名为 Lambda 表达式。 2.Lambda 表达式简介： Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段 可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵 活的代码。 Lambda 表达式的本质只是一个"语法糖",你可以使用更少的代..
lambda和Stream
一枚数学专业的小码农的博客
07-18 533
lambda以及stream介绍及应用
lambda之Stream流式编程
yangzhe19931117的博客
12-08 694
lambda之Stream流式编程
JDK1.8新特性详解：Lambda、Stream API与时间日期API
Stream API是JDK1.8中的一个重要改进，它提供了一种处理集合的新方式，支持序列化操作，如过滤、映射、归约等。Stream API可以进行并行处理，显著提高了大规模数据处理的效率。 **5、接口的默认方法和静态方法** ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值