lambda

什么是lambda

把“一块代码”赋给了一个变量。而“这块代码”，或者说“这个被赋给一个变量的函数”，就是一个Lambda表达式。其实就是个匿名函数。

为什么要用lambda

使用lambda表达式可对一个接口进行简洁的实现。

lambda对接口的要求

要求接口中定义的必须实现的抽象方法只能有一个（必须要实现的，不是default修饰的）。
Java8对接口加了一个新特性：default，修饰接口方法，就可以有默认实现，这样实现类可以实现该方法也可以不实现。
@FunctionalInterface
修饰函数式接口的，接口中抽象方法只能有一个。

实现接口的三种方式

public static void main(String[] args) {
    //实现接口方法实现
    CompareImpl compare = new CompareImpl();
    System.out.println(compare.compare(10,5));
    
    //内部类方法实现
    Compare compare1 = new Compare() {
        public int compare(int a,int b){
            return a-b;
        }
    };
    System.out.println(compare1.compare(10,5));
    
    //lanbda实现
    Compare compare2 = (a,b) -> a - b;
    System.out.println(compare2.compare(10,5));
}

lambda语法

public static void main(String[] args) {
    //lambda的基础语法
    //lambda是一个匿名函数
    //参数列表  方法体
    //() ：参数列表
    //()： 方法体
    // -> lambda运算符  goes to
    
    //无参无返回
    NoneReturnNoneParameter lambda1=() -> {
        System.out.println("hello");
    };
    lambda1.test();
    
    //无返回单参数
    NoneReturnSingleParameter lambda2=(a) ->{
        System.out.println(a);
    };
    lambda2.test(2);
    //无返回值多参
    NoneReturnDualParameter lambda3=(a,b) ->{
        System.out.println(a+b);
    };
    lambda3.test(10,20);
    
    //有返回值单参
    SingleReturnSingleParameter lambda4=(a) ->{
        return a;
    };
    System.out.println(lambda4.test(33));
    
    //有返回值多参
    SingleReturnDualParameter lambda5=(a,b) ->{
        return a*b;
    };
    System.out.println(lambda5.test(10,20));
}

lambda语法精简

public static void main(String[] args) {
    //语法精简：
    //1.参数类型精简：在接口中的方法中，已经定义了参数的数量和类型，因此在lambda中参数类型可省略，要省略全省略
    NoneReturnDualParameter lambda1=(a,b)->{
        System.out.println(a+b);
    };
    lambda1.test(10,20);
    
    //2.参数小括号:如果方法中参数只有一个时，()可省略
    NoneReturnSingleParameter lambda2 = a ->{
        System.out.println(a);
    };
    lambda2.test(100);
    
    //3.方法体{}：只有一句可省略
    NoneReturnSingleParameter lambda3=a -> System.out.println(a);
    lambda3.test(200);
    
    //4.方法体只有一条return语句，在省略{}同时也要省略return
    SingleReturnDualParameter lambda4=(a,b) -> a+b;
    System.out.println(lambda4.test(1,1));
}

方法引用

public class Syntax3 {
    public static void main(String[] args) {
        //方法引用：
        //将lambda指向一个已经实现的方法
        //语法：方法的隶属者::方法名
        //注意：参数的数量和类型一定要和接口中定义的方法一致；返回值的类型也要和接口中的方法返回值一样
        //用途：封装
        	
        SingleReturnSingleParameter lambda2= new Syntax3()::change;
        System.out.println(lambda2.test(10));
        
        //静态方法这样用
        SingleReturnSingleParameter lambda1= a -> changer(a);
        System.out.println(lambda1.test(20));
    }
    private int change(int a){
        return a*1000;
    }
    private static int changer(int a){
        return a*2000;
    }
}

构造方法引用

public class Syntax4 {
    public static void main(String[] args) {
    
        PersonCreater personCreater=()->new Person();
        personCreater.getPerson();
        
        //构造方法的引用
        PersonCreater creater1= Person::new;
        creater1.getPerson();
        
        PersonCreater2 creater2= Person::new;
        creater2.getPerson("aa",12);
    }
}
interface PersonCreater{
    Person getPerson();
}
interface PersonCreater2{
    Person getPerson(String name,int age);
}

集合排序

public class Execrise1 {
    //集合排序：
    //ArrayList<>
    public static void main(String[] args) {
        //需求：已知在一个ArrayList中有若干个Person对象，将这些对象按年龄排序。
        ArrayList<Person> list=new ArrayList<>();
        list.add(new Person("aa",11));
        list.add(new Person("ss",13));
        list.add(new Person("aaxx",18));
        list.add(new Person("xs",12));
        list.add(new Person("aaffr",15));
        
        list.sort((o1,o2)->o2.age-o1.age);
        System.out.println(list);
    }
}

TreeSet排序

public class Execrise2 {
    public static void main(String[] args) {
        //TreeSet
        //用lambda实例化Comparator接口，实例化TreeSet
        TreeSet<Person> set = new TreeSet<>((o1,o2)->{
            return o1.age>=o2.age ? -1 :1;
            /*if(o1.age>=o2.age){
                return -1;
            }else {
                return 1;
            }*/
        });
        set.add(new Person("aa",11));
        set.add(new Person("ss",13));
        set.add(new Person("aaxx",18));
        set.add(new Person("xs",12));
        set.add(new Person("aaffr",15));
        
        System.out.println(set);
    }
}

list遍历

public class Execrise3 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,0,1,2,3,4,5,6,7,11,8,9);
        
        //list.forEach(x-> System.out.println(x));
        //list.forEach(System.out::println);
        
        list.forEach(ele->{
            if(ele%2==0){
                System.out.println(ele);
            }
        });
    }
}

返回集合中符合条件的元素

public class Execrise4 {
    //返回集合中符合条件的元素
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("aa",11));
        list.add(new Person("ss",13));
        list.add(new Person("aaxx",18));
        list.add(new Person("xs",12));
        list.add(new Person("aaffr",15));
        
        /*Iterator<Person> it = list.iterator();
        while (it.hasNext()){
            Person next = it.next();
            if(next.age>13){
                it.remove();
            }
        }*/
        
        //lambda实现：
        //将集合中的每个元素放入test方法中，返回true则移除
        list.removeIf(ele->ele.age>13);
        System.out.println(list);
    }
}

开启线程

public class Execrise5 {
    public static void main(String[] args) {
        //需求：开辟线程
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println(i);
            }
        }).start();
        
        /* 匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(i);
                }
            }
        }).start();*/
    }
}

闭包

public class ClosureDemo {
    //闭包
    public static void main(String[] args) {
        int n=getNumber().get();
        System.out.println(n);
    }
    //闭包：提升变量的生命周期，这样就可以获取到某个方法中的局部变量
    private static Supplier<Integer> getNumber(){
        int num=10;
        
        return ()->num;
    }
}

闭包2

public class ClosureDemo2 {
    public static void main(String[] args) {
        int a=10;
        Consumer<Integer> c=ele->{
            System.out.println(a);
        };
        c.accept(a);
    }
}

系统自带函数式接口

public class FunctionInterfaces {
    public static void main(String[] args) {
        //系统自带的函数式接口
        
        //Predicate<T>  ： 参数：T   返回值：Boolean
        //IntPredicate          int       boolean   (long/double)
        
        //Consumer<T>   :  参数：T   返回值：void
        //Int/Double/LongConsumer int./.      void
        
        //Function<T,R> :  参数：T   返回值：R
        Int/Double/LongFunction int./.      void
        
        //Supplier<T>   :  参数：无   返回值：T
        
        //UnaryOperator<T> :   参数：T   返回值：T
        
        //BiFunction<T,U,R> : 参数：T，U    返回值：R
        
        //BinaryOperator<T>   : 参数：T，T    返回值：T
        
        //BiPredicate<T,U>   :  参数：T，U  返回值：Boolean
        
        //Consumer<T,U>   :  参数：T,U   返回值：void
        
        //常用接口：Predicate<T>  ，Function<T,R>  ，Consumer<T>  ，Supplier<T>
    }
}