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

今天药忘吃喽~ 2021-08-12 02:42 483阅读 0赞

### 概述 ###

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));
    	}
    }

输出样例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RoZV9CZXN0X0hhY2tlcg_size_16_color_FFFFFF_t_70][]

**补充说明：**

**以前用匿名实现类表示的现在都可以用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 + "]";
    	}
    	
    }

输出样例：

![20190903075625169.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RoZV9CZXN0X0hhY2tlcg_size_16_color_FFFFFF_t_70]: /images/20210811/f78da8eba26f4020a5e4dd4a0f36dc36.png
[20190903075625169.png]: /images/20210811/2cc5396b07ea4adcbfd18f302199954f.png