Lambda表达式

Lambda表达式

一：Lambda表达式概述

1.Lambda是什么

Lambda表达式（(参数列表)->{方法体；}）通常用来代替局部内部类。

2.为什么使用Lambda 表达式

	lambda表达式将大量替代匿名内部类的使用，简化代码的同时，
更突出了匿名内部类中最重要的那部分包含真正逻辑的代码。

二：使用Lambda表达式前提

1.什么是函数接口

	一个接口中仅有一个必须实现的抽象方法。用@FunctionalInterface修饰
一个接口，如果不报错则为函数接口，否则不为函数的接口。

2.Lambda使用前提

a:一个方法中的参数必须是函数接口(根据参数列表来进行确定哪一个接口的实现类)
  或者返回值类型是一个函数接口(根据返回值接口类型能看处是什么接口实现类);

b:可以推导(根据接口中方法的返回值类型和参数列表找出接口的实现类)和可省略。

3.Lambda表达做用来做一个方法的参数的推导过程

	调用一个函数，根据函数参数列表可以找到实现是哪一个接口。根据
lambda表达式的返回值类型和参数列表我们可以找到实现的方法。

三：Lambda表达式的代码实现

1.无参数无返回值类型

//测试类
public class Demo02 {
    public static void main(String[] args) {
		
        invokeCook(()->{
            System.out.println("吃饭啦！");
        });
    }

    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}
 
 //接口
 @FunctionalInterface
public interface Cook {
   void makeFood();
}

2.有参数有返回值类型

a:
public class Demo03 {
    public static void main(String[] args) {

        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("张三",24));
        list.add(new Student("李四",54));
        
        Collections.sort(list,(o1,o2)->{
            return o1.getAge()-o2.getAge();
        });
    }
}

b:
//测试类
public class Demo04 {
    public static void main(String[] args) {
        int sum = getSum(5,4,(i,j)->{
            return i - j;
        });
        System.out.println(sum);
    }

    public static int getSum(int i, int j, Calculator calculator) {
        return calculator.calc(i,j);
    }
}

//接口
public interface Calculator {
    int calc(int a, int b);
}

3.返回Lambda表达式

public static void main(String[] args) {

        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("张三",24));
        list.add(new Student("李四",54));
        list.add(new Student("王五",74));
        list.add(new Student("赵六",14));

        Collections.sort(list,getComparator());
        for (Student student : list) {
            System.out.println(student.getName() + "=" + student.getAge());
        }
    }
    
    
    public static Comparator<Student> getComparator(){
        return (o1,o2)->{
            return o1.getAge() - o2.getAge();
        };
    }
}

4.注意

Comparator接口有2个抽象方法：
   int compare(T o1, T o2);：必须被实现的抽象方法
   boolean equals(Object obj);接口不能直接使用，必须有实现类,所有的类继承
        					  自Object，间接重写实现了equals方法
        						
总结：Comparator是函数接口。

四：Lambda的简写格式

1:什么情况下能对Lambda能简写

	a:参数的类型可以省略
	b:参数只有一个可以把小括号省略
	c:当方法体只有一句代码。可以把中括号，return，分号，一起省略不写。

2:例子

(i,j)->{return i - j;}  可以简写为：(i,j)->i - j
(i)->{return i;} 可以简写为i->i

五：为什么使用函数接口来创建常用接口

	JDK为了避免各个程序定义一些重复的无效的函数式接口，所以，
它就提供了一些常用的函数式接口

六：Supplier(创建无参数有返回值类型接口)

a:
//有返回值无参数
public class Demo06 {
    public static void main(String[] args) {

        print(()->{
            return "Lambda表达式。";
        });
    }

    public static void print(Supplier supplier){
        //返回值为Object
        Object o = supplier.get();  
        System.out.println(o);
    }
}

b:
public class Demo07 {
    public static void main(String[] args) {
        int[] arr = {1,222,33,44,55,666,77};
        printMax(()->{
            int max = arr[0];
            for (int i : arr) {
                if(max < i){
                    max = i;
                }
            }
            return max;
        });
    }

    public static void printMax(Supplier supplier){
        Object o = supplier.get();
        System.out.println(o);
    }
}

七：Consumer(创建仅有一个参数，无返回值的接口)

a:
//只接受一个参数
public class Demo08 {
    public static void main(String[] args) {

        toUp(a->{
            System.out.println(a.toUpperCase());
        },"aaaBBBccc");
        
    }

    public static void  toUp(Consumer<String> consumer,String str){
        consumer.accept(str);
    }
}

b:
public class Demo09 {
    public static void main(String[] args) {

        makeString(a->{
            System.out.println(a.toUpperCase());
        },b->{
            System.out.println(b.toLowerCase());
        },"aaaabbbbbCCCC");
    }

    public static void makeString(Consumer<String> consumer1,Consumer<String> consumer2,String str){
        //让一个字符串变为大写小写
        /*consumer1.accept(str);
        consumer2.accept(str);*/
        //和上面一样
        //consumer1.andThen(consumer2).accept(str);
		//让当多个消费者按顺序消费数据。
		consumer1.andThen(consumer2).andThen(consumer2).andThen(consumer1).accept(str);

		//最后一行执行结果
		/*AAAABBBBBCCCC
		aaaabbbbbcccc
		aaaabbbbbcccc
		AAAABBBBBCCCC*/
    }
}

c:andThen的底层源码
        return (T t) -> { this.accept(t); after.accept(t); };

八：回顾零散知识

1.Arrays类

a:概述
	对数组进行操作的工具类
b:常用方法
	将数组转化为字符串
	public static String toString(基本数据类型[] 数组名);
	将数组进行排序
	public static基本数据类型[] sort(基本数据类型[] 数组名); 

2.Collections类

a:概述
	对集合操作的工具类
b:常用的方法
	 //T... elements:第二个参数可以为数组，也可以为多个参数；
	- public static <T> boolean addAll(Collection<T> c, T... elements) 
	-  `:往集合中添加一些元素。
	
	- public static void shuffle(List<?> list)
	-  打乱顺序`:打乱集合顺序。
	
	- public static <T> void sort(List<T> list)
	- :将集合中元素按照默认规则排序。
	
	- public static <T> void sort(List<T> list，Comparator<? super T> )
	- :将集合中元素按照指定规则排序。