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 con = new Consumer() {
			public void accept(String str) {
				System.out.println(str);
			}
		};
		con.accept("测试二");
		Consumer con2 = (str) -> {
			System.out.println(str);
		};
		con2.accept("Lambda表达式第二种形式");
	}

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

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

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

输出样例：

补充说明：

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

【二】函数式接口

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

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

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

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

java内置四大核心接口：

• Consumer 消费型接口:对类型为T的对象应用操作，包含方法：void accept(T t)
• Supplier 供给型接口：返回类型为T的对象，包含方法：T get();
• Function 函数型接口：对类型为T的对象应用操作，并返回结果R类型的对象。包含方法：R apply(T t);
• Predicate 断定型接口：确定类型为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的对象应用操作，包含方法：void accept(T t)
 * Supplier 供给型接口：返回类型为T的对象，包含方法：T get();
 * Function 函数型接口：对类型为T的对象应用操作，并返回结果R类型的对象。包含方法：R apply(T t);
 * Predicate 断定型接口：确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t);
 * java中还有其他的接口这里不做陈述，基本形式相同。
 * 
 */
public class FunctionalInterface {
	public static void main(String[] args) {
		/*consumerTest(500,new Consumer() {
			@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 al=predicateTest(list,new Predicate() {
			@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 al=predicateTest(list,t->t.contains("江"));
		for(String river:al) {
			System.out.print(river+"\t");
		}
		
		/*Object obj=supplierTest(list,new Supplier