Lambda表达式

目录

Lambda表达式

函数式接口

---

Lambda表达式

package Lambda;
​
import org.junit.Test;
​
import java.util.Comparator;
import java.util.function.Consumer;
​
/**
 *Lambda表达式的使用
 * 1、举例 (o1,o2) -> Integer.compare(o1,o2);
 * 2、格式：
 *          ->        ：Lambda操作符 或箭头操作符
 *          ->左边    ：Lambda形参列表（1其实就是接口中的抽象方法的形参列表）
 *          ->右边    ：Lambda体（其实就是重写的抽象方法的方法体）
 * 3、Lambda表达式的使用：（6种）
 *      总结：
 *          ->左边    ： Lambda形参列表的参数类型可以省略；
 *                      如果Lambda形参列表只有一个参数，其一对()也可以省略；
 *
 *          ->右边    ：Lambda体应该使用一对{}包裹；
 *                      如果lambda只有一条执行语句(可能是return语句)，可以省略一对大括号(return关键字);
 *
 * 4、Lambda表达式的本质：作为函数式接口的实例(接口中只能有一个抽象方法)
 *
 * 5、如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
 */
public class LambdaTest1 {
    //语法格式一： 无参，无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("你好");
            }
        };
        r1.run();
        System.out.println("***************");
        Runnable r2 = () ->{
            System.out.println("你好");
        };
        r2.run();
    }
    //语法格式二：Lambda 需要一个参数，但是没有返回值
    @Test
    public void test2(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("你在哪呢");
        System.out.println("************************");
        Consumer<String> consumer2 = (String s)->{
            System.out.println(s);
        };
        consumer2.accept("我也不知道");
    }
    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为"类型推断"
    @Test
    public void  test3(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("你在哪呢");
        System.out.println("************************");
​
        Consumer<String> consumer2 = (s) ->{
            System.out.println(s);
        };
        consumer2.accept("我在这");
    }
    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void tes4(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("你在哪呢");
        System.out.println("************************");
​
        Consumer<String> consumer2 = s ->{
            System.out.println(s);
        };
        consumer2.accept("我在这");
    }
    //语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        int compare = com1.compare(11, 12);
        System.out.println(compare);
        System.out.println("*******************************");
        Comparator<Integer> com2 = (o1,o2) ->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
    }
    //语法格式六：当Lambda体只有一条语句时，return与大括号若有，可以省略
    @Test
    public void test6() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        int compare = com1.compare(11, 12);
        System.out.println(compare);
        System.out.println("*******************************");
        Comparator<Integer> com2 = (o1,o2)-> o1.compareTo(o2);
        System.out.println(com2.compare(12, 6));
    }
}

函数式接口

 

 

• 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口

package Lambda;
​
​
import org.junit.Test;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
​
/**
 *java内置的4大核心函数式接口
 *  消费型接口   Consumer<T>     void accept(T t)
 *  供给性接口   Supplier<T>     T get()
 *  函数型接口   Function<T,R>   R apply(T t)
 *  断定型接口   Predicate<T>    boolean test(T t)
 */
public class LambdaTest2 {
    @Test
    public  void test1(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double money) {
                System.out.println("买东西去");
            }
        });
        System.out.println("***************************");
        happyTime(6000, (money) ->System.out.println("买东西去"));
​
    }
    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }
    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","天津","东京","西京");
​
        List<String> list1 = fString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(list1);
        System.out.println("***********************************");
        List<String> list2 = fString(list, s -> s.contains("京") );
        System.out.println(list2);
    }
    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> fString (List<String> list, Predicate<String> pre){
​
        ArrayList<String> fList = new ArrayList<>();
        for (String s : list){
            if(pre.test(s)){
                fList.add(s);
            }
        }
        return fList;
    }
​
}