JDK1.8新特性(部分)【Lambda表达式、函数式接口】--学习JavaEE的day41

day41

JDK1.8新特性

JDK1.8新特性简介

  • 速度更快 - 优化底层源码,比如HashMap、ConcurrentHashMap
  • 代码更少 - 添加新的语法Lambda表达式
  • 强大的Stream API
  • 便于并行
  • 最大化减少空指针异常 - Optional

Lambda表达式

简介

Lambda是一个匿名函数(方法), 允许把函数作为一个方法的参数 。利用Lambda表达式可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。

一般都是优化匿名内部类

基础语法

无参数、无返回值的抽象方法

java 复制代码
public class Test1 {
	@Test
	public void test01() {
//		I1 i1 = new I1() {
//			@Override
//			public void method() {
//				System.out.println("传统使用匿名内部类的方式");
//			}
//		};
//		i1.method();

//		I1 i1 = ()->{
//			System.out.println("使用lambda表达式的方式");
//		};
//		i1.method();
        
        //lambda表达式里面只有一个语句情况,大括号可以省略进行简化代码
		I1 i1 = ()-> System.out.println("采用Lambda表达式的方式");
		i1.method();
	}
}
interface I1{
	public void method();//无参数、无返回值的抽象方法
}

一个参数、无返回值的抽象方法

外部new匿名内部类调用方法时,参数看接口定义的规范里的参数类型

java 复制代码
public class Test01 {
	public static void main(String[] args) {
		
//		I1 i1 = new I1() {
//			@Override
//			public void method(String str) {
//				System.out.println("使用传统匿名内部类的方式:" + str);
//			}
//		};
//		i1.method("过往云烟");
		
//		I1 i1 = (String str)->{
//			System.out.println("使用lambda表达式的方式:" + str);
//		};
//		i1.method("过往云烟");
		
//		I1 i1 = (String str)->System.out.println("使用lambda表达式的方式:" + str);
//		i1.method("过往云烟");
		
		
//		I1 i1 = (str)->System.out.println("使用lambda表达式的方式:" + str);
//		i1.method("过往云烟");
		
		I1 i1 = str->System.out.println("使用lambda表达式的方式:" + str);
		i1.method("过往云烟");
	}
}
public interface I1 {

	public void method(String str);//一个参数、无返回值的抽象方法
}

多个参数、无返回值的抽象方法

java 复制代码
public class Test01 {
	public static void main(String[] args) {
		
//		I1 i1 = new I1() {
//			@Override
//			public void method(String str, int i) {
//				System.out.println("使用传统匿名内部类的方式:" + str + " -- " + i);
//			}
//		};
//		i1.method("过往云烟", 666);
		
//		I1 i1 = (String str,int i)->{
//			System.out.println("使用lambda表达式的方式:" + str + " -- " + i);
//		};
//		i1.method("过往云烟", 777);
		
//		I1 i1 = (String str,int i)->System.out.println("使用lambda表达式的方式:" + str + " -- " + i);
//		i1.method("过往云烟", 888);
		
		I1 i1 = (str, i)->System.out.println("使用lambda表达式的方式:" + str + " -- " + i);
		i1.method("过往云烟", 999);
		
	}
}
public interface I1 {
    //多个参数、无返回值的抽象方法
	public void method(String str,int i);
}

多个参数、有返回值的抽象方法

java 复制代码
public class Test01 {
	public static void main(String[] args) {
	
//		I1 i1 = new I1() {
//			@Override
//			public String method(int a, int b) {
//				return "使用传统匿名内部类的方式:" + (a+b);
//			}
//		};
//		String method = i1.method(10, 10);
//		System.out.println(method);
		
//		I1 i1 = (int a,int b)->{
//			return "使用lambda表达式的方式:" + (a+b);
//		};
//		String method = i1.method(20, 20);
//		System.out.println(method);
		
		I1 i1 = (a, b)-> "使用lambda表达式的方式:" + (a+b);
		String method = i1.method(30, 30);
		System.out.println(method);
		
	}
}
public interface I1 {
	//多个参数、有返回值的抽象方法
	public String method(int a,int b);
}
注意点
  1. 重写方法的形参只有一个时,可以不加小括号
  2. Lambda表达式当中不允许声明一个与局部变量同名的参数或者局部变量
  3. Lambda表达式中访问外层的局部变量,外层的局部变量自动变成隐式常量,默认添加final
  4. 重写方法的形参同时加类型或同时不加类型
java 复制代码
public class Test1 {
	@Test
	public void test01() {
		int x;
		int num = 10;
		I1 i1 = x -> System.out.println(x + (num++));
        i1.method(1000);
		
		I2 i2 = (int x,int y) -> {
			int result = x+y;
			return result;
		};
		int result = i2.method(10, 20);
		System.out.println(result);
	}
}
interface I1{
	public void method(int num1);
}
interface I2{
	public int method(int num1,int num2);
}
案例
案例1

1.调用Collections.sort()方法,通过定制排序比较两个Student对象(先按年龄比较,年龄相同按照薪资比较),使用Lambda表达式作为参数传递
注意:比较时注意不能用减,因为doublue减后的小数会在转int损失精度,ps:0.2变为0

java 复制代码
public class Test01 {

	public static void main(String[] args) {
		
		List<Student> stuList = Arrays.asList(
				new Student("张三", 28, 4800,Course.JAVA),
				new Student("李四", 36, 7200,Course.JAVA),
				new Student("王五", 19, 9600,Course.HTML),
				new Student("赵六", 42, 6100,Course.HTML),
				new Student("孙七", 23, 9600,Course.PYTHON),
				new Student("吴八", 28, 3000,Course.PYTHON));
		
//		Collections.sort(stuList, new Comparator<Student>() {
//			@Override
//			public int compare(Student o1, Student o2) {
//				if(o1.equals(o2)){
//					return 0;
//				}
//				
//				int compare = Integer.compare(o1.getAge(), o2.getAge());
//				if(compare != 0){
//					return compare;
//				}
//				
//				return Double.compare(o1.getSalary(), o2.getSalary());
//			}
//		});
		
		Collections.sort(stuList, (o1,o2)->{
			if(o1.equals(o2)){
				return 0;
			}
			
			int compare = Integer.compare(o1.getAge(), o2.getAge());
			if(compare != 0){
				return compare;
			}
			
			return Double.compare(o1.getSalary(), o2.getSalary());
		});
		
		for (Student stu : stuList) {
			System.out.println(stu);
		}
		
	}
}
public enum Course{//课程枚举
	JAVA,HTML,PYTHON;
}
public class Student{//学生类
	
	private String name;
	private int age;
	private double salary;
	private Course course;
    //有参、无参、get、set方法【略】
@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((course == null) ? 0 : course.hashCode());
		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;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (course != other.course)
			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() {
		StringBuilder builder = new StringBuilder();
		builder.append("Student [name=");
		builder.append(name);
		builder.append(", age=");
		builder.append(age);
		builder.append(", salary=");
		builder.append(salary);
		builder.append(", course=");
		builder.append(course);
		builder.append("]");
		return builder.toString();
	}

}
案例2

2.创建I1接口,创建抽象方法:public String getValue(String str),在测试类中编写方法使用接口作为参数,将一个字符串转为大写,并作为方法的返回值

java 复制代码
public class Test01 {
    
	public static void main(String[] args) {
		
		String str = method("abc", (x)-> {
			return x.toUpperCase();
		});
		System.out.println(str);
		
		
	}
	
	public static String method(String str,I1 i1){
		return i1.getValue(str);
	}
}

interface I1{
	public String getValue(String str);
}
案例3

3.创建I1<T,R>接口,泛型T为参数,R为返回值,创建抽象方法:public R add(T t1,T t2),在测试类中编写方法使用接口作为参数,计算两个long类型的和

java 复制代码
public class Test01 {

	public static void main(String[] args) {
		
		long addLong = addLong(100,200,(a,b)->{
			return a+b;
		});
		System.out.println(addLong);
		
		
	}
	
	public static long addLong(long l1,long l2,I1<Long,Long> i1){
		return i1.add(l1, l2);
	}
}
interface I1<T,R>{
	public R add(T t1,T t2);
}

函数式接口

简介

函数式接口是指仅仅只包含一个抽象方法的接口,jdk1.8提供了一个@FunctionalInterface注解来定义函数式接口,如果我们定义的接口不符合函数式的规范便会报错。配合Lambda表达式一起使用

四大核心函数式接口
函数式接口 参数类型 返回类型 用途
Consumer 消费型接口 T void void accept(T t);
Supplier 供给型接口 void T T get();
Function<T, R> 函数型接口 T R R apply(T t);
Predicate 断言型接口 T boolean booelan test(T t);
BiConsumer<T, U> T,U void 对类型为T,U参数应用操作。包含方法为void accept(T t,U u);
BiFunction<T, U, R> T,U R 对类型为T,U参数应用操作,并返回R类型的结果。包含方法为R apply(T t,U u);
UnaryOperator extends Function<T, T> T T 对类型为T的对象进行一元运算,并返回T类型的结果。包含方法为T apply(T t);
BinaryOperator extends BiFunction<T,T,T> T,T T 对类型为T的对象进行二元运算,并返回T类型的结果。包含方法为T apply(T t1,T t2);
ToIntFunction ToLongFunction ToDoubleFunction T int long double 分别计算int、long、double值的函数
IntFunction LongFunction DoubleFunction int long double R 参数为int、long、double类型的函数

应用场景:当项目中需要一个接口,并且该接口中只有一个抽象方法,就没必要去创建新的接口,直接选择Java提供的使用合适的函数式接口即可

案例替换

对Lambda表达式案例,使用合适的函数式接口去替换I1
创建I1接口,创建抽象方法:public String getValue(String str),

在测试类中编写方法使用接口作为参数,将一个字符串转为大写,并作为方法的返回值

注意:使用合适的函数式接口去替换I1

函数和方法:前端习惯称函数,后端习惯称方法,简单理解一个意思但非区别

函数式接口,一个抽象方法,超过就会报错

函数式接口替换接口,就案例来看更改方法里的接口,用函数调用方法,少一层

java 复制代码
public class Test01 {

	public static void main(String[] args) {
		
		String str = method("abc", (x)->{
			return x.toUpperCase();
		});
		System.out.println(str);
		
		
	}
	
	public static String method(String str,Function<String, String> fun){
		return fun.apply(str);
	}
}
public class Test02 {

	public static void main(String[] args) {
		
		String str = method("abc", (x)->{
			return x.toUpperCase();
		});
		System.out.println(str);
		
		
	}
	
	public static String method(String str,UnaryOperator<String> uo){
		return uo.apply(str);
	}
}

创建I1<T,R>接口,泛型T为参数,R为返回值,创建抽象方法:public R add(T t1,T t2),

在测试类中编写方法使用接口作为参数,计算两个long类型的和

java 复制代码
public class Test01 {

	public static void main(String[] args) {
		
		long addLong = addLong(100,200,(a,b)->{
			return a+b;
		});
		System.out.println(addLong);
		
		
	}
	
	public static long addLong(long l1,long l2,BiFunction<Long, Long, Long> bf){
		return bf.apply(l1, l2);
	}
}
public class Test02 {
	public static void main(String[] args) {
		
		long addLong = addLong(100,200,(a,b)->{
			return a+b;
		});
		System.out.println(addLong);
		
		
	}
	
	public static long addLong(long l1,long l2,BinaryOperator<Long> bo){
		return bo.apply(l1, l2);
	}
}

总结

1.lambda表达式(其实就有优化匿名内部类的方案)

注意:使用lambda表达式必须有多态的思想

2.函数式接口

该接口中只有一个抽象方法

@FunctionInterface这个注解表示该接口是函数式接口

经验:

如果你想玩转lambda表达式,必须先去学习匿名内部类+多态

函数式接口应用场景:需求要你写个接口,这个接口只有一个抽象方法,就用函数式接口去代替

相关推荐
吾日三省吾码1 小时前
JVM 性能调优
java
弗拉唐2 小时前
springBoot,mp,ssm整合案例
java·spring boot·mybatis
Red Red2 小时前
网安基础知识|IDS入侵检测系统|IPS入侵防御系统|堡垒机|VPN|EDR|CC防御|云安全-VDC/VPC|安全服务
网络·笔记·学习·安全·web安全
oi773 小时前
使用itextpdf进行pdf模版填充中文文本时部分字不显示问题
java·服务器
少说多做3433 小时前
Android 不同情况下使用 runOnUiThread
android·java
知兀3 小时前
Java的方法、基本和引用数据类型
java·笔记·黑马程序员
蓝黑20204 小时前
IntelliJ IDEA常用快捷键
java·ide·intellij-idea
Ysjt | 深4 小时前
C++多线程编程入门教程(优质版)
java·开发语言·jvm·c++
shuangrenlong4 小时前
slice介绍slice查看器
java·ubuntu