java 的lambda表达式

 

为何使用 Lambda 表达式

lLambda 是一个匿名函数，咱们能够把 Lambda 表达式理解为是一段能够传递的代码（将代码像数据同样进行传递）。使用它能够写出更简洁、更灵活的代码。做为一种更紧凑的代码风格，使Java的语言表达能力获得了提高。

Lambda 表达式

Lambda 表达式语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操做符。这个操做符为 “->” ， 该操做符被称为 Lambda 操做符或箭头操做符。它将 Lambda 分为两个部分：

 

左侧：指定了 Lambda 表达式须要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

 

 

package day26_1;

import org.junit.Test;

//写一个接口 B , 其中有一个抽象方法 String upper(String string);
//使用匿名内部类的方式实现这个接口, 方法中把参数里的字符串变成大写并返回
//使用lambda表达式方式实现这个接口, 方法中把参数里的字符串变成大写并返回
interface B {
	String upper(String string);
}


// 最常规的作法
class B2 implements B {
	@Override
	public String upper(String string) {
		return string.toUpperCase();
	}
}
/*
interface C {
	Integer max(Integer n1, Integer n2); // 取最大值
}
*/
interface C<X extends Comparable> { // X在这里就是泛型， 表示某种类型
	X max(X n1, X n2); // 取两个对象中的最大值
}
/*
 * 写一个接口 C ， 定义抽象方法 Integer max(Integer n1, Integer n2);
 *在测试方法中， 使用匿名内部类对象的方式完成这个接口的实现， 并调用方法， 打印输出
 *使用lambda表达式的方式来完成相同的功能 
 * */
public class LambdaExer {
	
	@Test
	public void test2() {
		C<Integer> c = new C<Integer>() {
			@Override
			public Integer max(Integer n1, Integer n2) {
				return n1 > n2 ? n1 : n2;
			}
		};
		Integer max = c.max(10, 50);
		System.out.println(max);
		
		// lambda表达式 ： 关注参数列表 -> 方法体 
		//C c2 = (Integer n1, Integer n2) -> {return n1 > n2 ? n1 : n2;};
		C<String> c2 = (n1, n2) -> n1.compareTo(n2) > 0 ? n1 : n2; // 通用性最好
		String max2 = c2.max("asfj", "ASFJ");
		System.out.println(max2);
	}
	
	@Test
	public void test1() {
		B b1 = new B2();
		String string1 = b1.upper("abcdefg");
		System.out.println(string1);
		
		// 匿名内部类
		B b2 = new B() {// 类体 
			@Override
			public String upper(String string) {
				return string.toUpperCase();
			}
		};
		String string2 = b2.upper("abcdefg");
		System.out.println(string2);
		// lambda表达式, 只关注 抽象方法参数列表 -> 方法体
		B b3 = string -> string.toUpperCase();
		String string3 = b3.upper("abcdefg");
		System.out.println(string3);
	}
}


package day26_1;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

/**
 * lambda表达式 : 须要接口, 接口中必须只有一个抽象方法, 而且方法实现的方法体中只有一行语句.
 * 	语法 : 参数列表 -> 方法体 
 * lambda表达式本质上就是一个匿名内部类的对象， 而且类型只能是接口类型
 * 
 * 	主要用于代替匿名内部类对象
 */

@FunctionalInterface
interface A {
	public String test(Integer num);
	//public Integer test2(String num);
}



public class LambdaTest {
	
	@Test
	public void test3() {
		A a1 = new A() {
			@Override
			public String test(Integer num) {
				return String.valueOf(num);
			}

		};
		// 参数类型能够省略, 而且, 若是参数列表中只有一个参数时, ()也省略
		A a2 = num -> String.valueOf(num);
		String string = a2.test(200);
		System.out.println(string);
	}
	
	@Test
	public void test2() {
		List<Student> list = StudentData.getList();
		// 比较器用于完成某两个学生对象的比较
		Comparator<Student> comparator = new Comparator<Student>() {
			// 类体至关于接口的实现子类
			@Override
			public int compare(Student s1, Student s2) {
				return (int)(s1.getScore() - s2.getScore());
			}
		};
		Collections.sort(list,comparator);
		
		for (Student student : list) {
			System.out.println(student);
		}
		
		System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
		// lambda表达式来作这个事情, 要求分数降序
		// 若是咱们的方法体中, 只有一行语句, 能够省略{}, 若是有return 也能够省略
		//Comparator<Student> comparator2 = (Student s1, Student s2) -> {return (int)(s2.getScore() - s1.getScore());};
		// 由于左边的类型中已经有了泛型, 全部右面的表达式中的类型是能够推断的, 那么能够省略
		//Comparator<Student> comparator2 = (Student s1, Student s2) -> (int)(s2.getScore() - s1.getScore());
		Comparator<Student> comparator2 = (s1, s2) -> (int)(s2.getScore() - s1.getScore());
		Collections.sort(list, comparator2);
		
		for (Student student : list) {
			System.out.println(student);
		}
	}
	
	@Test
	public void test1() {
		Runnable r1 = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + " : hello");
			}
		};
		
		new Thread(r1).start();
		
		// lambda表达式 : 省略父类或接口, 省略方法修饰符和返回值, 方法名, 只保留参数列表, 和 方法体
		// lambda表达式本质上就是一个匿名内部类的对象
		Runnable r2 = () -> System.out.println(Thread.currentThread().getName() + " : Hello2 ");
		
		new Thread(r2).start();
	}

}