第14章 lambda表达式与流处理-CSDN博客

本文链接：https://blog.csdn.net/snowman_tunan/article/details/133772223

14.1、lambda表达式

lambda表达式可以用非常少的代码实现抽象方法。lambda表达式不能独立执行，因此必须实现函数式接口，并且会返回一个函数式接口的对象。语法格式为：

（） - > 结果表达式\代码块

这个方法按照这样的代码来实现

参数—>结果表达式\代码块

（参数1，参数2....n）—>结果表达式\代码块

lambda表达式实现函数式接口

函数式接口指的是仅包含一个抽象方法的接口。

interface SayHi{
	String say();
}
public class NoParamterDemo {

	public static void main(String[] args) {
		SayHi sh=new SayHi() {
			public String say() {
				return "这里是内部类";
			}
		};
		System.out.println(sh.say()); 
		//使用lambda表达式补全方法体
		SayHi sh1=()->{return "这里是lambda表达式";};
		System.out.println(sh1.say()); 
	}

}

interface AddInterface{
	int add(int a,int b);
}
public class ParamterDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用匿名内部类补全方法体
		AddInterface add1=new AddInterface(){
		public int add(int a,int b) {
			return a+b;
		}	
		};
		System.out.println("内部类："+add1.add(3, 5));
		//使用lambda表达式补全方法体
		AddInterface add2=( a, b)->{
				return a+b;
			};
			System.out.println("lambda："+add2.add(3, 5));
	}

}

interface CheckGrade{
	String check(int grade);
}
public class GradeDemo {

	public static void main(String[] args) {
		CheckGrade g=(n)->{
			if(n>=90&&n<=100) {
				return "成绩为优";
			}else if(n>=80&&n<90) {
				return "成绩为良";
			}else if(n>=60&&n<80) {
				return "成绩为中";
			}else if(n>=0&&n<60) {
				return "成绩为差";
			}else{
				return "成绩无效";
			}
		};
		System.out.println(g.check(89));
	}

}

1.函数式接口

函数式接口的式京包含的一个抽象方法的接口，接口中的方法简单明了地说明了接口地，如用途线程解耦Runnable，动作时间监听接口，ActionListener等，开发者可以创建自定义地函数式接口如下

interface Mylnterface{
    void method();
}
//定义了一个没有方法体的抽象方法

2. Iambda表达式实现无参数抽象方法

很多函数接口的抽放方法是无参数的，如线程接口Runnable接口只有一个run()方法这样的无参抽象方法在 Iambda表达式中使用（）表示代码如

本实例，直接在 Iambda表达式中创建了SayHiInterface接口对象，并制定了一个字符串作为接口方法的返回值，最后在输出语句中，pi对象就是Iambda表达式创建出的对象，当pi调用接口方法时就输出了 Iambda表达式指定的字符串

3.Iambda表达式实现也有参的抽象方法

代码如下

package 第十四章;
interface AddInterface{
	int add(int a , int b );
}
public class ParamterDemo {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用匿名内部类方法补全方法体（有参数)
		AddInterface add1 = new AddInterface () {
			public int add(int a , int b) {
				return a+b ; 
			}
		};
		System.out.println("内部类:"+add1.add(3, 5));	
//使用lambda表达式补全方法体  （有参数)
AddInterface add2 =  (a,b) ->{ return a+b ; 
};
System.out.println("lambda表达式:"+add2.add(9, 5));	
}
}

在这实例中，函数式接口的抽象方法有两个参数，Iambda表达式的圆括号内也写了两个参数对应的抽象方法，注意 Iambda表达式中的参数不需要与抽象方法的参数名称相同，但是顺序必须相同

4.Iambda表达式使用代码块

当函数式接口的抽象方法需要实现复杂的逻辑而不是返回一个简单的表达式的话，就需要在Iambda表达式中使用代码块 Iambda表达式会自动判断返回类型释放符合抽象方法的定义

代码如下

package 第十四章;
interface CheckGrade{
	String check(int grade);
}
public class GradeDemo {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CheckGrade g = (n)->{
			if(n>90 && n<=100) {//使用if判断
				return "成绩优异";//return
			}else if(n>80 && n<=90) {
				return "成绩为良";
			}else if(n>60 && n<=80) {
				return "成绩为中";
			}else if(n>0 && n<=60) {
				return "成绩为差";
			}else {
				return "成绩无效";
			}
		};
		System.out.println(g.check(89));
	}
 
}

Iambda表达式调用外部变量

Iambda表达式除了可以调用定义好的参数，还可以调用表达式以外的变量，但是，这些外部变量有些可以被更改有些则不行

1.Iambda表达式无法更改局部变量

局部变量在lambda表达式中默认被定义为final（静态）也就是说Iambda表啊但是只能调用局部变量，却不能改变其值代码如下

package 第十四章;
interface Variablelnterface1{
	void method();
}
 
public class VariableDemo1 {
	public static void main (String []args) {
		int value = 100;
		Variablelnterface1 v =()->{
			int num = value-90;
			value = 12;
		};
	}
}

2.lambda表达式可以更改成员变量

成元年两式在lambda表达式中不是被final修饰的，所以lambda表达式可以改变其值

例题如下

package 第十四章;
interface Variableinterface1{//创建接口
	void method();//测试方法
}
public class VariableDemo2 {//测试类
	int  value =100;//创建类的成员变量
	public void action () {//创建类的成员方法
		Variableinterface1 v =() ->{//实现接口
			value = -12;//更改成员变量，没提示任何错误
		};
		System.out.print("运行接口方法钱value"+value);//运行接口方法钱先输出成员变量值
		v.method();//运行接口方法
		System.out.print("运行接口方法后value"+value);//运行接口方法后在输出成员变量值
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		VariableDemo2 demo=new VariableDemo2();//创建测试类对象
		demo.action();//调用测试类方法
	}
}

lambda表达式与异常处理

很多接口的抽象方法为了保证程序的安全性，会在定义时抛出异常，但是lambda表达式中并没有抛出异常的语法，这是因为lambda表达式会默认抛出抽象原有的异常每当此方法被调用时则需要进行异常处理

14.2方法的引用

lambda表达式还添加了一类新语法，用来一弄方法也就是方法可以作为一个对象被调用，根据不同的方法类型，方法的引用包括了引用静态方法，引用成员方法和引用构造方法等等。

引用语法如下

类名：：静态方法名 //“：：”是引用的意思
主要的使用方法如下

package 第十四章;
 
interface AddInterface1{
	int add(int a ,int b );
}
public class paramterDemo1 {
	static int add (int a , int b){//需要添加static变量（让这个方法变成静态方法  然后达到只能坐在本类使用）
		return a+b ;
	}
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1 paramterDemo1  pd  = new paramterDemo1();//去掉static的方法
		AddInterface1 add1 = paramterDemo1::add;//使用paramterDemo1中的add方法来补全方法体然而达成效果
		System.out.println("方法的引用："+add1.add(3, 5));
	}
 
}

运行结果如下

方法的引用：8
引用成员方法

引用成员方法如下

对象名：：成员方法名
跟引用静态方法不同这个操作符左边一定要是对象名右边不是类名。这种语法可以达到抽象方法按照抽象方法按照类成员方法逻辑来实现的目的

实际代码如下

package 第十四章;
 
import java.text.SimpleDateFormat;
import java.util.Date;
 
interface instanceMethodlnterface{//接口
	String method (Date date );//没有方法体  抽象方法
}
public class lnstanceMethidDemo {//有方法体
public String format(Date date ) {
	SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd");//格式化日期
	return sdf.format(date);//返回
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		lnstanceMethidDemo demo =new lnstanceMethidDemo();//new对象让以下代码找到方法 然而调用  达到补全上方没有方法体的代码
		instanceMethodlnterface im =demo::format;//im调用demo对象方法体中的方法  然而达到补全该方法中的方法体
		Date date =new Date ();
		System.out.println("默认格式："+date );
		System.out.println("接口输出的格式："+im.method(date));
	}
 
}

运行结果如下

默认格式：Sat Oct 14 02:14:04 CST 2023
接口输出的格式：2023-10-14
引用带有泛型的方法

泛型是java开发经常使用到的功能 “：：”操作符支持引用泛型的方法。除了方法外，“：：”操作符也支持引用带有泛型的类

引用构造方法

lambda表达式有3种引用构造方法的语句，分别是引用无参构造方法，引用有参构造方法和引用数组构造方法

1.引用无参构造方法

引用无参构造方法的语句如下

类名：：new
因为构造方法与与类名相同，如果操作符左右都写类名的话，会让操作符以为是在引用与类名相同的静态方法，这昂会导致程序出现Bug，所以引用构造方法的语法使用了new关键字，操作符右侧new关键字，表示引用构造方法

这个语法有一点要注意：new关键字之后没有圆括号，也没有参数的定义。如果类中既有无参构造方法，又有有参构造方法。使用引用构造方法语句后，究竟哪一个构造方法被引用了呢，引用哪个构造方法是有函数决定的，“：：”操作符会返回与抽象方法的参数结构相同的构造方法，如果找不到参数接口相同的构造方法，则会繁盛编译错误

以如下代码所示

package 第十四章;
interface Constructorslnterface2{//创建集合
	ConstructorsDemo2 action();//调用有参构造方法
}
public class ConstructorsDemo2 {//测试类
public ConstructorsDemo2() {//无参构造方法
	System.out.println("调用无参构造方法");//
}
public  ConstructorsDemo2 (int i){//有参构造方法
	System.out.println("调用有参构造方法");
}
public static void main (String []args) {//主方法//
	Constructorslnterface2 a = ConstructorsDemo2::new ;//调用ConstructorsDemo2类的构造方法
ConstructorsDemo2 b =a.action();//通过有参构造方法创建对象  
}
}

运行结果如下

调用无参构造方法
引用有参构造方法

引用有参构造方法的语句与无参构造方法中类似区别为一个有参数一个没有参数

代码如下

package 第十四章;
interface Constructorslnterface2{//创建集合
	ConstructorsDemo2 action(int i);//调用有参构造方法
}
public class ConstructorsDemo2 {//测试类
public ConstructorsDemo2() {//无参构造方法
	System.out.println("调用无参构造方法");//
}
public  ConstructorsDemo2 (int i){//有参构造方法
	System.out.println("调用有参构造方法，参数为："+i);
}
public static void main (String []args) {//主方法//
	Constructorslnterface2 a = ConstructorsDemo2::new ;//调用ConstructorsDemo2类的构造方法
ConstructorsDemo2 b =a.action(123);//通过有参构造方法创建对象  
}
}

运行结果输出

调用有参构造方法，，参数为：123
引用数组构造方法

java开发可能出现这样一种特殊场景：把数组类型当作泛型，如果犯法返回值为泛型，在这种特殊场景下，方法就应该是返回一个数组类型的结果，如果要求抽象方法引用构造方法，又要返回数组类型结果，这种场景下抽象方法的参数有了另外一个含义：数组个数抽象方法的参数可以决定返回的数组长度，但是数组中的元素并不是有值的，还需要再次赋值。引用数组构造方法的语法也会有所不同语法如下

类名[]：：new
代码如下：

package 第十四章;
interface ArraysConslnterface<T>{
	//抽象方法返回对象数组，方法参数决定了数组的个数
	T action(int n);
}
public class ArraysConsDemo {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArraysConslnterface<ArraysConsDemo[]> a = ArraysConsDemo[]::new ;
		ArraysConsDemo array[] = a.action(3);
		array[0] = new ArraysConsDemo();
		array[1] = new ArraysConsDemo();
		array[2] = new ArraysConsDemo();
	}
 
}

Fuction接口

在此之前的所有实例中，想要使用iambda表达式都需要先创建或调用已有的函数式接口，但java.util.function包已经提供了很多预定义函数式接口，就是没有实现任何功能，仅用来封装lambda表达式的对象，该包中最长用的接口时Function<T,R>，接口有以下两个泛型

T：被操作的类型，可以理解为方法参数类型
R：操作结果类型，可以理解为方法的返回类型
表Function接口方法

package 第十四章;
 
import java.util.function.Function;
 
public class FunctionlnDemo {
	Function <Integer[],String>function = (n)->{
		StringBuilder str=new StringBuilder();
		for (Integer num:n) {
			str.append(num);
			str.append('.');
		}
		str.deleteCharAt(str.length()-1);
		return str.toString();
	};
	public static void main (String []args) {
		Integer [] ip = {192,168,1,1};
		System.out.print(demo.function.apply(ip));
	}
}

14.3 流处理

流处理有点类似与数据库语句可以执行非常复杂的过滤映射和查找手机功能，并且代码量很少但是唯一的确定时代码可读性不高，如果开发者基础不好可能看不懂流API所表达的含义

创建员工表封装成一个集合里面有名字年龄薪资性别部门代码如下：

package 第十四章;
 
import java.util.ArrayList;
import java.util.List;
 
public class Employee {
	private String name ;
	private int age ; 
	private double salsary;
	private String sex ;
	private String dept;
	//构造方法
	public Employee(String name, int age, double salsary, String sex, String dept) {
		super();
		this.name = name;
		this.age = age;
		this.salsary = salsary;
		this.sex = sex;
		this.dept = dept;
	}
	@Override
	//重写toString方法   方便打印员工信息
	public String toString() {
		return "Employee [name=" + name + ", age=" + age + ", salsary=" + salsary + ", sex=" + sex + ", dept=" + dept
				+ "]";
	}
	//以下是员工的属性的getter方法
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public double getSalsary() {
		return salsary;
	}
	public String getSex() {
		return sex;
	}
	public String getDept() {
		return dept;
	}
	static List<Employee> getEmpList(){
		List<Employee> list = new ArrayList<Employee>();
		list.add(new Employee("喜羊羊",18,9000,"男","运营部"));//向列表中添加数据
		list.add(new Employee("美羊羊",15,3000,"女","设计部"));
		list.add(new Employee("废羊羊",22,9000,"男","开发部"));
		list.add(new Employee("灰太狼",33,14000,"男","销售部"));
		list.add(new Employee("红太狼",28,8000,"女","人事部"));
		list.add(new Employee("懒洋洋",17,10300,"女","运营部"));
		return list;//返回list集合
	}
}