Java中Lambda简化代码实现

使用Lambda简化多线程实现

在没有进行简化代码时，我们使用的是这样的代码创建多线程。

public class RunableIpm implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"实现了一个线程");
	}
}
public class IRunnable {
	public static void main(String[] args) {
		RunableIpm ipm = new RunableIpm();
		Thread th = new Thread(ipm);
		th.start();//第一个线程
		
		new Thread(new RunableIpm()).start();//第二个线程
		new Thread(//简化代码，使用匿名内部类实现多线程。第三个线程
			new RunableIpm() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(Thread.currentThread().getName()+"海绵宝宝在吃棉花糖");
				}
			}
		).start();
	}
}
Thread-0实现了一个线程
Thread-1实现了一个线程
Thread-2海绵宝宝在吃棉花糖

代码分析：
Thread类需要Runnable接口作为参数，其中抽象run方法是用来指定线程任务内容的。
为了指定线程任务，就必须创建Runnable接口的实现类，就算我们使用匿名内部类，也需要重写run方法。
但是，似乎只有方法体才是关键。

使用Lambda实现多线程创建。

public class LambdaIpmThread {
	public static void main(String[] args) {
		new Thread(//简化代码，使用匿名内部类实现多线程。第三个线程
			new RunableIpm() {
				@Override
				public void run() {
				System.out.println(Thread.currentThread().getName()+"海绵宝宝在吃棉花糖");
				}
			}
		).start();
		//简化代码	
		new Thread(()->{System.out.println(Thread.currentThread().getName()+"海绵宝宝在吃棉花糖");}
			).start();
	}
}
//Thread-0海绵宝宝在吃棉花糖
//Thread-1海绵宝宝在吃棉花糖

Lambda表达式的标准格式：
（参数列表）->{一些重写方法的代码}
由三部分组成：
():接口中抽象方法的参数，参数之间用逗号分割。
->:把参数传递个方法体
{}:重写接口的抽象方法。

有参数无返回值：

//定义一个接口
public interface Cook {
	public abstract void makeFood();//无参数无返回值方法
}
//主方法
public class LambdaNopAndr{
	public static void main(String[] args) {
		//调用方法，方法中的参数是Cook接口对象，我们这里传递匿名内部类对象。
		invokeCook(new Cook() {
			@Override
			public void makeFood() {
				System.out.println("海绵宝宝吃饭了");
			}
		});
		//使用Lambda,省略了接口对象，也不用显示复写方法。
		invokeCook(()->{
			System.out.println("派大星吃饭了");
		});
	}
	//把Cook接口对象传入方法中作为参数。
	private static void invokeCook(Cook cook) {
		cook.makeFood();
	}
}
//Thread-0海绵宝宝吃饭了
//Thread-1派大星吃饭了

有参数有返回值：

public class LambdaPandR {

	public static void main(String[] args) {
		Person[] arr = {
				new Person("海绵宝宝",18),
				new Person("派大星",19),
				new Person("章鱼哥",25)
		};
		Arrays.sort(arr, new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
				return o1.getAge()-o2.getAge();
			}
		});
		//使用Lambda方式，有参数有返回值。省略了泛型方法Comparator
		Arrays.sort(arr, (o1,o2)->{
			return o1.getAge()-o2.getAge();
		});
		for(Person p:arr) {
			System.out.println(p);
		}
	}
}
Person [name=海绵宝宝, age=18]
Person [name=派大星, age=19]
Person [name=章鱼哥, age=45]

有参数有返回值，传递多个参数练习。

public interface Calculator {
	//定义一个抽象方法，传递两个参数
	public abstract int cal(int a,int b);
}
public class Cal {

	public static void main(String[] args) {
		//调用的时候对象进行调用
		invoke(10,20,new Calculator() {
			@Override
			public int cal(int a, int b) {
				return a+b;
			}
		});
		//使用Lambda简化匿名对象，只需要传入复写方法的参数
		invoke(15,25,(a,b)->{//这个抽象方法传的有参数
			return a+b;
		});
	}
	//传递两个int参数，传递Caculator接口对象作为参数
	public static void invoke(int a,int b,Calculator c) {
		int sum = c.cal(a,b);
		System.out.println(sum);
	}
}

Lambda使用前提：
必须有接口，且要求接口中只有一个抽象方法。有且只有一个抽象方法的接口称为函数式接口。
以上代码还可进一步简化，作为学习阶段暂简化至此。