Java8新特性【一】：概述、Lambda表达式、函数式接口

概述

Java8是自Java5以来最具革命性的版本，为Java语言、编译器、类库、开发工具与JVM带来了大量的新特性。

优势：

• 速度更快
• 代码更少（增加了新的语法：Lambda表达式）
• 强大的Stream API
• 便于并行
• 最大化减少空指针异常：Optional
• Nashorn引擎，允许在JVM上运行JS应用

【一】Lambda表达式

1.格式：左边 -> 右边

->   Lambda操作符

左边是Lambda的形参列表（其实就是抽象方法的参数列表）

右边是Lambda体（其实就是重写的抽象方法的方法体）

2.6种形式：无参无返回值

第一种：无参无返回值

第二种：一个参数，但是没有返回值

第三种：数据类型可以省略，因为可以由编译器推断得出，称为“类型推断”

第四种：Lambda表达式若只需要一个参数时，小括号可以省略

第五种：Lambda表达式有多个参数，并且有返回值

第六种：当Lambda体只有一条语句时，return与大括号有，都可以省略

代码示例：

package lambda.test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest1 {
	public static void main(String[] args) {
		test1();
		System.out.println("---------------------------------");
		test2();
		System.out.println("---------------------------------");
		test3();
		System.out.println("---------------------------------");
		test4();
		System.out.println("---------------------------------");
		test5();
		System.out.println("---------------------------------");
		test6();
	}

	// 6种形式
	// 第一种：无参无返回值
	public static void test1() {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("测试一");
			}
		};
		r.run();
		Runnable r2 = () -> System.out.println("Lambda表达式第一种形式");
		r2.run();
	}

	// 第二种：一个参数，但是没有返回值
	public static void test2() {
		Consumer<String> con = new Consumer<String>() {
			public void accept(String str) {
				System.out.println(str);
			}
		};
		con.accept("测试二");
		Consumer<String> con2 = (str) -> {
			System.out.println(str);
		};
		con2.accept("Lambda表达式第二种形式");
	}

	// 第三种：数据类型可以省略，因为可以由编译器推断得出，称为“类型推断”
	public static void test3() {
		Consumer<String> con3=(str)->{
			System.out.println(str);
		};
		con3.accept("Lambda表达式第三种形式");
	}

	public static void test4() {
		Consumer<String> con4=str->{
			System.out.println(str);
		};
		con4.accept("Lambda表达式第四种形式");
	}

	public static void test5() {
		Comparator<Integer> com=new Comparator<Integer>() {
			public int compare(Integer num1,Integer num2) {
				System.out.println(num1);
				System.out.println(num2);
				return num1.compareTo(num2);
			}
		};
		System.out.println(com.compare(12,56));
		Comparator<Integer> com2=(num1,num2)->{
			System.out.println(num1);
			System.out.println(num2);
			return num1.compareTo(num2);
		};
		System.out.println(com2.compare(56,12));
	}

	public static void test6() {
		Comparator<Integer> com=new Comparator<Integer>() {
			public int compare(Integer num1,Integer num2) {
				return num1.compareTo(num2);
			}
		};
		System.out.println(com.compare(12,56));
		Comparator<Integer> com2=(num1,num2)->num1.compareTo(num2);
		System.out.println(com2.compare(12,56));
	}
}

输出样例：

补充说明：

以前用匿名实现类表示的现在都可以用Lambda表达式

【二】函数式接口

Lambda表达式的本质就是函数式接口的实例。

函数式接口：只包含一个抽象方法的接口。

可以在一个接口上使用@FunctionalInterface注解来检验一个函数是否为函数式接口。

在java.util.function包下定义了java8的丰富的函数式接口。

java内置四大核心接口：

• Consumer<T> 消费型接口:对类型为T的对象应用操作，包含方法：void accept(T t)
• Supplier<T> 供给型接口：返回类型为T的对象，包含方法：T get();
• Function<T,R> 函数型接口：对类型为T的对象应用操作，并返回结果R类型的对象。包含方法：R apply(T t);
• Predicate<T> 断定型接口：确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t);

  java中还有其他的接口这里不做陈述，基本形式相同。

代码示例：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/*java内置四大核心接口：
 * Consumer<T> 消费型接口:对类型为T的对象应用操作，包含方法：void accept(T t)
 * Supplier<T> 供给型接口：返回类型为T的对象，包含方法：T get();
 * Function<T,R> 函数型接口：对类型为T的对象应用操作，并返回结果R类型的对象。包含方法：R apply(T t);
 * Predicate<T> 断定型接口：确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t);
 * java中还有其他的接口这里不做陈述，基本形式相同。
 * 
 */
public class FunctionalInterface {
	public static void main(String[] args) {
		/*consumerTest(500,new Consumer<Double>() {
			@Override
			public void accept(Double t) {
				// TODO Auto-generated method stub
				System.out.println("本周共消费金额(元)："+t);
			}
		});*/
		consumerTest(500,money->System.out.println("本周共消费金额(元)："+money));
		
		/*List list=Arrays.asList("黄河","长江","渭河","汨罗江","黄浦江");
		ArrayList<String> al=predicateTest(list,new Predicate<String>() {
			@Override
			public boolean test(String t) {
				// TODO Auto-generated method stub
				return t.contains("江");
			};
		});
		for(String river:al) {
			System.out.print(river+"\t");
		}*/
		List list=Arrays.asList("黄河","长江","渭河","汨罗江","黄浦江");
		ArrayList<String> al=predicateTest(list,t->t.contains("江"));
		for(String river:al) {
			System.out.print(river+"\t");
		}
		
		/*Object obj=supplierTest(list,new Supplier<Object>() {
			@Override
			public String get() {
				// TODO Auto-generated method stub
				return list.toString();
			}
		});
		System.out.println(obj);*/
		Object obj=supplierTest(list,()->list.toString());
		System.out.println(obj);
		
		TreeMap<String,Student> map=new TreeMap<>();
		map.put("贫困", new Student(001,"王二小"));
		map.put("特困", new Student(002,"张三"));
		map.put("贫困", new Student(003,"李四"));
		map.put("一般", new Student(78,"王五"));
		map.put("一般", new Student(005,"赵六"));
		Student stu=functionTest(map,new Function<String,Student>(){
			@Override
			public Student apply(String t) {
				// TODO Auto-generated method stub
				return map.get(t);
			}
		});
		System.out.println(stu);
	}
	
	
	public static void consumerTest(double money,Consumer<Double> con) {
		con.accept(money);
	}
	
	public static ArrayList<String> predicateTest(List<String> list,Predicate<String> pre) {
		ArrayList<String> arraylist= new ArrayList<>();
		for(String str:list) {
			if(pre.test(str)) {
				arraylist.add(str);
			}
		}
		return arraylist;
	}
	
	public static Object supplierTest(List<Object> list,Supplier<Object> sup) {
		for(Object object:list) {
			return sup.get();
		}
		return null;
	}
	//Function<T,R> 函数型接口：对类型为T的对象应用操作，并返回结果R类型的对象。包含方法：R apply(T t);
	public static Student functionTest(Map<String,Student> map,Function<String,Student> fun) {
		return fun.apply("特困");
	}
}
class Student{
	private int id;
	private String name;
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + "]";
	}
	
}

输出样例：