Java1.8新特性：函数式接口与lambda表达式和方法引用配合使用

lambda表达式

• lambda是一个匿名函数，使用lambda表达式可以有效地使代码变得更加简洁
• 格式：参数 -> {代码}
• 基本实例

	//创建线程的步骤
	new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("1");
            }
        });
    //lambda写法
    new Thread( () -> System.out.println("1"));

• 参数：如果没有参数使用括号，一个参数可以省略括号，多个参数需要使用括号

	new HashMap<>().forEach((key,value) 
	-> System.out.println("key:" + key + " value:" + value));
	new ArrayList<>().forEach( value 
	-> System.out.println(value));

• 代码：如果只有一行代码那么可以不写大括号，多行语句必须写大括号

	new HashMap<>().forEach((key,value) -> {
            System.out.println("key:" + key);
            System.out.println("value:" + value);
        });

• 返回值：如果加了return哪怕只有一行代码也要加大括号，如果不加return可以省略大括号

	() -> {return 1};
    () -> 1;

方法引用

• 方法引用是通过::来调用方法，方法引用不可以单独使用，需要放在函数式接口中代替lambda表达式使用
• 四种调用方式：
  • 静态方法引用
  • 实例方法引用
  • new方法引用
  • 实例对象方法引用

class Father{
    public static void sout(){
        System.out.println("sout");
    }

    public void send(){
        System.out.println("send");
    }
}

public static void main(String[] args) {
		//静态方法
        Father::sout;
        //实例方法
        Father::send;
        //new 方法
        Father::new;
        Father father = new Father();
        father::send;
}

函数式接口

• 函数式接口就是一个接口中有且只有一个抽象方法，然后再接口上加上@FunctionalInterface注解标志他是一个函数式接口，接口中可以有默认方法
• 常见的四种函数式接口：

- 供给型接口：
	- Supplier，没有参数一个返回值
	- 供给，理解就是你要给别人供给，所以要有一个返回值

	//供给型接口 没有参数一个返回值
	//提供方法
    public static Object supplier(Supplier<Object> supplier){
        return supplier.get();
    }
    public static void main(String[] args) {
    	//方法调用
        supplier(new Supplier<Object>() {
            @Override
            public Object get() {
            	//返回值
                return 1;
            }
        });
        //lambda表达式使用
        supplier(() -> 1);
        //方法引用 () -> 1  等价于 Object::new
        //相当于返回了一个Object对象
        supplier(Object::new);
    }

- 消费型接口：
	- Consumer，一个参数没有返回值
	- 消费，理解就是你要消费，所以需要一个参数

	//消费型接口 一个参数没有返回值
	//提供方法
    public static void consumer(int param,Consumer<Integer> consumer){
  	    consumer.accept(param);
	}
    public static void main(String[] args) {
        //方法调用
	    consumer(1,new Consumer<Integer>() {
             @Override
        	 public void accept(Integer integer) {
        	 	//消费参数
         	     System.out.println(integer);
        	 }
    	 });
    	 //lambda
    	 consumer(1,integer -> System.out.println(integer));
    	 //方法引用
    	 consumer(1,System.out.println(integer));
    }

- 断言型接口：
	- Predicate，一个参数一个boolean值
	- 断言，就是给你一个参数你判断然后返回boolean值

	//断言型接口  一个参数一个boolean值
    public static boolean predicate(int param,Predicate<Integer> predicate){
        return predicate.test(a);
    }
    public static void main(String[] args) {
        //方法调用
	    predicate(1,new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer == 1;
            }
        });
        //lambda
        predicate(1,integer -> 1 == 1);
    }

- 函数型接口：
	- Function，一个参数一个返回值

	//函数式接口 一个参数一个返回值
    public static String function(int param,Function<Integer,String> function){
        return function.apply(param);
    }
    public static void main(String[] args) {
        	//方法调用
	    function(1,new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return "str";
            }
        });
        //lambda
        function(1,() -> "str");
    }

- 自定义函数式接口

@FunctionalInterface
interface Sum<T>{
    T all(int a,int b);
}

public static int myFunction(int a,int b,Sum<Integer> sum){
        return sum.all(a,b);
    }

public static void main(String[] args){
	//调用方法
	myFunction(1, 2, new Sum<Integer>() {
     @Override
        public Integer all(int a, int b) {
            return a + b;
        }
    });
    //lambda
	myFunction(1, 2, (x, y) -> x * y);
}