【Java】6.8 Lambda学习

目录

Lambda 表达式简介

Lambda 表达式

Lambda 语法精简

Lambda 方法引用

Lambda 构造方法引用

Lambda 综合练习

---

Lambda 表达式简介

【什么是Lambda】

Lambda是Java 8添加的一个新特性。说白了，Lambda就是一个匿名函数

【为什么要使用Lambda】

使用Lambda表达式可以对一个接口进行非常简洁的实现

【Lambda对接口的要求】

虽然可以使用Lambda表达式对某些接口进行简单的实现，但是并不是所有的接口都可以用Lambda表达式来实现。要求接口中定义的必须要实现的抽象方法只能是一个

 

@FunctionInterface标记

Lambda 表达式

Lambda是一个匿名函数，主要由：【参数列表】和【方法体】组成
【格式】

• (): 用来描述参数列表
• {}: 用来描述方法体
• ->: lambda运算符，读作goes to

import interfaces.LambdaNoneReturnMutipleParameter;
import interfaces.LambdaNoneReturnNoneParameter;
import interfaces.LambdaNoneReturnSingleParameter;
import interfaces.LambdaSingleReturnMutipleParameter;
import interfaces.LambdaSingleReturnNoneParameter;
import interfaces.LambdaSingleReturnSingleParameter;

/** 
 * @ClassName: LambdaTest
 * @description: lambda测试
 * @author: FFIDEAL
 * @Date: 2020年3月2日 下午10:10:11
 */

public class LambdaTest {
	public static void main(String[] args) {
		//1.lambda表达式的基本语法
		//Lambda是一个匿名函数
		//参数列表  方法体
		
		//(): 用来描述参数列表
		//{}: 用来描述方法体
		//->: lambda运算符，读作goes to
		
		//无参数无返回值的
		LambdaNoneReturnNoneParameter lambdatest1 = () -> {
			System.out.println("hello world");
		};
		
		lambdatest1.test();
		
		//一个参数无返回值
		LambdaNoneReturnSingleParameter lambdatest2 = (int a) -> {
			System.out.println(a);
		};
		lambdatest2.test(20);
		
		//多个参数无返回值
		LambdaNoneReturnMutipleParameter lambdatest3 = (int a, int b) ->{
			System.out.println(a + b);
		};
		lambdatest3.test(20, 30);
		
		//无参数有返回值
		LambdaSingleReturnNoneParameter lambdatest4 = () -> {
			return 60;
		};
		System.out.println(lambdatest4.test());
		
		//有返回值单个参数
		LambdaSingleReturnSingleParameter lambdatest5 = (int a) -> {
			return a;
		};
		System.out.println(lambdatest5.test(70));
		
		//有返回值多个参数
		LambdaSingleReturnMutipleParameter lambdatest6 = (int a,int b) -> {
			return a + b;
		};
		System.out.println(lambdatest6.test(30, 50));
	}
}

/**
 * @ClassName: Createlambda
 * @description: 三种实现接口的方法，其中重点是lambda表达式，这种方法更简洁
 * @author: FFIDEAL
 * @Date: 2020年3月2日 下午9:32:28
 */

public class Createlambda {
	public static void main(String[] args) {
		// 1.通过接口实现类的方式
		Compare compare = new MyCompare();

		// 2.使用匿名内部类的方式
		Compare compare1 = new Compare() {

			@Override
			public int compare(int a, int b) {
				// TODO Auto-generated method stub
				return a - b;
			}
		};

		// 3.使用lambda表达式的方式实现接口
		Compare compare2 = (a, b) -> a - b;
	}
}

//创建一个实现接口的类
class MyCompare implements Compare {
	@Override
	// 重写Compare接口中的方法
	public int compare(int a, int b) {
		return a - b;
	}
}

@FunctionalInterface
//上面注释是检查接口中是否只有一个方法：函数式接口
interface Compare {
	// 创建一个接口
	int compare(int a, int b);
}

Lambda 语法精简

语法精简的四条规则

1. 参数类型。因为在接口中的抽象方法已经确定了参数类型，所以此时不用写参数类型
           注意：要省略参数类型就一起省略，不能出现有的省略，有的不省略的情况
2. 当只有一个参数的时候，可以省略括号
3. 当方法体中只有一条语句时，可以去掉大括号
4. 当方体中只有一条返回语句且去掉大括号时，需同时把return去掉

import interfaces.LambdaNoneReturnMutipleParameter;
import interfaces.LambdaNoneReturnSingleParameter;
import interfaces.LambdaSingleReturnSingleParameter;

/** 
 * @ClassName: LambdaClear
 * @description: Lambda语法精简
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午1:38:35
 */

public class LambdaClear {
	public static void main(String[] args) {
		//1.参数类型。因为在接口中的抽象方法已经确定了参数类型，所以此时不用写参数类型
		//注意：要省略参数类型就一起省略，不能出现有的省略有的不省略的情况
		LambdaNoneReturnMutipleParameter lc1 = (a , b) -> {
			System.out.println(a + b);
		};
		lc1.test(1, 2);
		
		//2.当只有一个参数的时候，可以省略括号
		LambdaNoneReturnSingleParameter lc2 = a -> {
			System.out.println(a);
		};
		lc2.test(4);
		
		//3.当方法体中只有一条语句时，可以去掉大括号
		LambdaNoneReturnSingleParameter lc3 = a -> System.out.println(a);
		lc3.test(5);
		
		//4.当方体中只有一条返回语句且去掉大括号时，需同时把return去掉
		LambdaSingleReturnSingleParameter lc4 = a -> a;
		System.out.println(lc4.test(6));
		
	}
}

Lambda 方法引用

方法引用的规则：

1. 方法引用：可以快速的一个Lambda表达式的实现直线一个已经实现了的方法
2. 语法：方法隶属者::方法名

注意：

1. 返回数量和类型一定要和接口中定义的方法一致
2. 返回值的类型一定要和接口中定义的方法一致

import interfaces.LambdaSingleReturnSingleParameter;

/** 
 * @ClassName: LambdaFunction
 * @description: 方法引用
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午2:06:54
 */

public class LambdaFunction {
	public static void main(String[] args) {
		/*
		 * 方法引用：
		 * 可以快速的一个Lambda表达式的实现直线一个已经实现了的方法
		 * 语法：方法隶属者::方法名
		 * 
		 * 注意：
		 * 1.返回数量和类型一定要和接口中定义的方法一致
		 * 2.返回值的类型一定要和接口中定义的方法一致
		 * */
		
		LambdaSingleReturnSingleParameter lf1 = a -> change(a) ;
		System.out.println(LambdaFunction.change(10));
		
		//方法引用：静态引用了change方法的实现
		LambdaSingleReturnSingleParameter lf2 = LambdaFunction::change;
		System.out.println(LambdaFunction.change(20));
		LambdaFunction lf = new LambdaFunction();
		
		//方法引用：非静态引用了goesTo方法的实现
		LambdaSingleReturnSingleParameter lf3 = a -> lf.goesTo(a);
		System.out.println(lf.goesTo(30));
		LambdaSingleReturnSingleParameter lf4 = lf :: goesTo;
		System.out.println(lf.goesTo(40));

	}
	//创建一个静态方法
	private static int change(int a) {
		return a * 12 ;
	}
	//创建一个非静态方法
	private int goesTo(int a) {
		return a * 21 ;
	}
}

Lambda 构造方法引用

/** 
 * @ClassName: LambdaTest2
 * @description: 构造方法
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午2:54:11
 */

public class LambdaTest2 {
	public static void main(String[] args) {
		//构造方法的引用
		PersonCreater pc = Person4::new;
		Person4 a = pc.getPerson();
		
		PersonCreater2 pc2 = Person4 :: new;
		Person4 b = pc2.getPerson("张三", 5);
	}
}

interface PersonCreater{
	Person4 getPerson();
}

interface PersonCreater2{
	Person4 getPerson(String name,int age);
}

Lambda 综合练习

/** 
 * @ClassName: Person
 * @description: 
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午2:50:09
 */

public class Person4 {
	private String name;
	int age;
	
	public Person4(){
		System.out.println("运行了无参构造器");
	}
	
	public Person4(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("运行了有参数构造器");
	}

	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 String toString() {
		return "name：" + name + "age: " + age ;
	}
	
}

案例1：集合排序

import java.util.ArrayList;

/** 
 * @ClassName: LambdaList
 * @description: 集合排序。按年龄降序
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午3:08:49
 */


public class LambdaList {
	public static void main(String[] args) {
		ArrayList<Person4> list = new ArrayList<Person4>();
		
		list.add(new Person4("LiMing",20));
		list.add(new Person4("WangJin",22));
		list.add(new Person4("LiuDehua",21));

		list.sort((o1 , o2) -> o1.age - o2.age);
		
		System.out.println(list);
	}
}

 案例2：TreeSet

import java.util.TreeSet;

/** 
 * @ClassName: LambdaSet
 * @description: Tree Set
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午3:27:06
 */


public class LambdaSet {
	public static void main(String[] args) {
		//使用Lambda表达式来实现Comparator接口，并实例化一个TreeSet对象
		TreeSet<Person4> ts = new TreeSet<Person4>((o1 , o2) -> o1.age - o2.age);
		
		ts.add(new Person4("LiMing",20));
		ts.add(new Person4("WangJin",22));
		ts.add(new Person4("LiuDehua",21));
		
		System.out.println(ts);
	}
}

案例3：删除符合条件的对象（removeIf）

import java.util.ArrayList;
import java.util.ListIterator;

/** 
 * @ClassName: LambdaDelete
 * @description: 删除集合中满足条件的语句
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午3:44:28
 */

public class LambdaDelete {
	public static void main(String[] args) {
		ArrayList<Person4> list = new ArrayList<Person4>();
		
		list.add(new Person4("LiMing",20));
		list.add(new Person4("WangJin",22));
		list.add(new Person4("LiuDehua",21));
		
		/*
		ListIterator<Person4> it = list.listIterator();
		while(it.hasNext()) {
			Person4 ele = it.next();
			if(ele.age > 21) {
				it.remove();
			}
		}
		System.out.println(list);
		*/
		
		list.removeIf(ele -> ele.age > 21);
		System.out.println(list);
	}
}

案例4：开辟一个线程，做一个线程的数字输出

/** 
 * @ClassName: LambdaThread
 * @description: 开辟一条线程，做一个数字输出
 * @author: FFIDEAL
 * @Date: 2020年3月3日 下午3:57:13
 */


public class LambdaThread {
	public static void main(String[] args) {
		Thread t = new Thread(() -> {
			for(int i = 0; i < 100; i++) {
				System.out.println(i);
			}
		});
		
		t.start();
	}
}