Java语言学习总结 扩展篇 Lambda函数的使用

Lambda函数

定义

Lambda表达式的标准格式:
由三部分一些参数一个箭头一段代码组成:

格式:
(参数列表) -> {一 些重写方法的代码};
解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
->:传递的意思，把参数传递给方法体{}
{}:重写接口的抽象方法

示例代码：

		//使用Lambda的格式实现一个多线程
		new Thread(()->{
			System.out.println(Thread.currentThread().getName() + "创建了一个新线程");
		}).start();

完整代码示例：
先建立一个抽象类

public interface EatClass {
	public abstract void makeFood();
}

再在测试类中用Lambda表达式调用抽象类对象

public class LambdTestClass {
	//定义一个方法，参数传递给EatClass接口
	//方法内部调用EatClass接口中的抽象方法
	public static void eatPre(EatClass eat) {
		eat.makeFood();
	}
	public static void main(String[] args) {
		//直接调用方法，传递EatClass参数
		eatPre(new EatClass() {
			@Override
			public void makeFood() {
				System.out.println("该吃饭了");
			}
		});

		//使用Lambda表达式，简化过程	}
		eatPre(()->{
			System.out.println("该吃饭了");
		});
	}
}

输出结果：

带有参数的Lambda表达式

示例代码：
先定义一个Person类

public class Person {
	String name;
	int age;

	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

在测试类中调用sort方法对Person类的对象根据年龄的升序排序：

import java.util.Arrays;
import java.util.Comparator;
public class LambdaSortClass {

	public static void main(String[] args) {
		Person[] arr= {
				new Person( "王三",23),
				new Person( "王四",26),
				new Person( "王五",12)
		};

		//使用sort方法通过年龄的升序进行排序，需定义个匿名内部类
		//Comparator的对象
		/*
		Arrays.sort(arr,new Comparator<Person>(){
			@Override
			public int compare(Person p1, Person p2) {
				return p1.getAge()- p2.getAge();
			}
		});
		*/
		
		//使用Lambda表达式，简化匿名内部类
		Arrays.sort(arr,(Person p1, Person p2)->{
			return p1.getAge()- p2.getAge();
		});
		
		for(Person p:arr) {
			System.out.println(p);
		}
	}

}

输出结果：

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

示例：
定义一个计算器接口，内含抽象方法将两个int数字相加得到和值并返回
定义一个Calculate接口：

public interface Calculate {
	//定义一个抽象方法，计算两数之和
	public abstract int calc(int a,int b);
}

在测试类中定义接口的匿名内部类抽象方法。

public class CalculateClass {

	/*
	 * 定义一个方法，参数传递两个int类型的整数
	 * 参数传递Calculate接口
	 * 方法内部调用Calculate中的方法calc计算两个整数和
	 */
	public static void invokeCalc(int a,int b,Calculate c) {
		int sum = c.calc(a, b);
		System.out.println(sum);
	}
	public static void main(String[] args) {
		//按照传统方法，直接调用invokeCalc方法，传递参数，求值
		invokeCalc(10,20,new Calculate() {
			@Override   //重写Calculate中的抽象方法
			public int calc(int a,int b) {
				return a+b;
			}
		});
		
		//使用lambda表达简化定义匿名内部类的过程
		invokeCalc(10,20,(int a,int b)->{
			return a+b;
		});

	}

}

输出结果：