Java8新特性--Lambda表达式、方法引用

一、Lambda表达式

Lambda是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码（将代码像参数一样传递）。

1.举例说明

@Test
public void test01(){
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("无参，无返回值");
        }
    };
    r1.run();

    System.out.println("使用Lambda表达式改写");
    Runnable r2 = ()-> {System.out.println("Lambda表达式 无参，无返回值");};
    r2.run();
}

格式：
->:Lambda操作符 或 剪头操作符<br/>
->左边：Lambda形参列表 = 接口中抽象方法的形参列表<br/>
->右边：Lambda方法体 = 重写的抽象方法的方法体

2.语法说明

先从最简单的没有参数没有返回值的情况介绍

一：无参，无返回值

@Test
public void test01(){
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("无参，无返回值");
        }
    };
    r1.run();

    System.out.println("****************");
    Runnable r2 = ()-> {System.out.println("Lambda表达式 无参，无返回值");};
    r2.run();
    //还可以继续优化，当返回体只有一条语句时，大括号{}可以进行省略
    Runnable r3 = ()-> System.out.println("Lambda表达式 无参，无返回值");
}

二：有一个参数，但是没有返回值

@Test
public void test02(){
    Consumer<String> consumer = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("有参数，没有返回值");
    System.out.println("*************");
    Consumer<String> lambdaConsumer = (String s)->System.out.println(s);
    lambdaConsumer.accept("Lambda表达式 有参数，没有返回值");
    // 数据类型也可以省略    
    Consumer<String> lambdaConsumer1 = (s)->System.out.println(s);
    // 参数的小括号也可以省略 
    Consumer<String> lambdaConsumer2 = s->System.out.println(s);
}

三：有两个或多个参数，多条执行语句，并且有返回值

@Test
public void test05(){
    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);
        }
    };
    System.out.println(com1.compare(12, 21));
    System.out.println("*************");
    // Lambda表达式进行改写
    Comparator<Integer> com2 = (o1,o2)->{
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(com2.compare(21, 12));
}

四：方法体只有一条语句时，return和{}都可以省略

@Test
public void test6(){
    Comparator<Integer> com1 = (o1, o2) -> {return o1.compareTo(o2);};
    System.out.println(com1.compare(12,6));
    System.out.println("**********");
    Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
    com2.compare(12,21);

}

3.总结

->左边：Lambda形参列表的参数类型可以省略（类型推断），如果Lambda形参列表只有一个参数，其中（）可以省略

->右边：Lambda体应该使用{}包裹，如果Lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return

二、函数式接口

如果一个接口只实现了一个抽象方法，则此接口就成为函数式接口

@FunctionalInterface
public interface MyInterface {
    void method1();
}

1.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)

消费型接口

/**
 * 消费型接口
 */
@Test
public void consumerTest(){
    happyTime(500, new Consumer<Integer>() {
        @Override
        public void accept(Integer money) {
            System.out.println("消费者消费了。。。" + money);
        }
    });
}
@Test
public void lambdaConsumerTest(){
    happyTime(300, d -> System.out.println("Lambda消费者消费了"+ d));
}

public void happyTime(int money, Consumer<Integer> consumer){
    consumer.accept(money);
}

断定型接口

/**
 * 断定型接口
 */
@Test
public void predicateTest(){
    List<String> list = Arrays.asList("abc","def","abd","ddd");
    List<String> filterList = filterString(list, new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.contains("d");
        }
    });
    System.out.println(filterList);
    //使用Lambda表达式改写
    System.out.println("*************");
    List<String> lambdaFilterList = filterString(list,s -> s.contains("京"));
    System.out.println(lambdaFilterList);
}

//根据给定的规则，过滤集合中的字符窜，此规则由Predicate的方法决定
public List<String> filterString(List<String> list, Predicate<String> pre){
    ArrayList<String> filterList = new ArrayList<>();
    for (String s : list){
        if (pre.test(s)){
            fi
            lterList.add(s);
        }
    }return filterList;
}

三、方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
  
• 方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
  
• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
  
• 格式：使用 “::” 将类与方法名分隔
  
• 如下三种主要使用情况：
  
• • 对象：：非静态方法
    
• • 类：：静态方法名
    
• • 类：：非静态方法

1.使用情景

对象：：实例方法

/**
 * 情况一 对象：：非静态方法
 * Consumer中的void accept（T t）
 * PrintStream中的void println（T t）
 * 参数列表，返回值相同
 */
@Test
public void test01(){
    Consumer<String> con1 = s -> System.out.println(s);
    con1.accept("123");
    System.out.println("********************");
    PrintStream ps = System.out;
    Consumer<String> con2 = ps::println;
    con2.accept("北京");
}

/**
 * Supplier中的T get（）
 * Employee中的String getName()
 * 参数列表，返回值相同
 */
@Test
public void test02(){
    Employee emp = new Employee(1001,"tom",23,5600);
    Supplier<String> sup1 = () ->  emp.getName();
    System.out.println(sup1.get());
    //因为方法体只有一条语句，所以省略了大括号和return
    Supplier<String> sup2 = () -> "返回";
    System.out.println(sup2.get());
    System.out.println("**************");
    //方法引用实现 对象：非静态方法
    Supplier<String> sup3 = emp::getName;
    System.out.println(sup3.get());
}

类：：静态方法

/**
 * 情况二 类：：静态方法
 * Comparator 中的int compare（T t1,T t2）
 * Integer 中的int compare（T t1,T t2）
 */
@Test
public void test(){
    Comparator<Integer> com1 = (t1,t2)->Integer.compare(t1,t2);
    System.out.println(com1.compare(12, 21));
    //类：：静态方法
    Comparator<Integer> com2 = Integer::compare;
    com2.compare(22,33);
}
@Test
/**
 * Function 中的 R apply(T t)
 * Math 中的Long round(Double d)
 */
public void test1(){
    Function<Double,Long> func1 = d -> Math.round(d);
    System.out.println(func1);
    System.out.println("***********");
    Function<Double,Long> func2 = Math::round;
}

类：：实例方法

/**
 * 情况三 类：：实例方法
 * Comparator 中的 int compare(T t1,T t2)
 * String 中的 int t1.compareTo(t2)
 * 两个参数，第一个参数作为调用者出现时，也有可能会出现方法引用
 */
@Test
public void test5(){
    Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
    System.out.println(com1.compare("abcd", "abd"));
    System.out.println("**************8");
    // t1（String）作为调用者去调用compareTo方法，没有必要写t1
    Comparator<String> com2 = String :: compareTo;
    System.out.println(com2.compare("abd", "abm"));
}

/**
 * BiPredicate中的boolean test(T t1,T t2);
 * String中的boolean t1.equals(t2)
 */
@Test
public void test05(){
    BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
    pre1.test("abd","abc");
    System.out.println("**********");
    BiPredicate<String,String> pre2 = String::equals;
    pre2.test("dd","dd");

}
/**
 * Function中的R apply（T t）
 * Employee中的String getName()
 */
@Test
public void test06(){
    Employee employee = new Employee(12,"姓名",15,600);
    Function<Employee,String> func1 = e -> e.getName();
    System.out.println(func1.apply(employee));
    System.out.println("**************");
    Function<Employee,String> func2 = Employee::getName;
    System.out.println(func2.apply(employee));
}

四、Stream API

使用StreamAPI对集合数据进行操作，类似于使用SQL执行的数据库查询
1.创建Stream

方式一：通过集合

@Test
public void test01(){
    List<Employee> employeeList = EmployeeData.getEmployees();
    //返回一个顺序流 default Stream<E> stream();
    Stream<Employee> stream = employeeList.stream();
    //返回一个并行流 default Stream<E> parallelStream();
    Stream<Employee> parallelStream = employeeList.parallelStream();
}

方式二：通过数组

@Test
public void test02(){
    //调用Arrays类的static<T> Stream<T> stream(T[] array);返回一个流
    int[] arr = new int[]{1,2,3,4,5};
    IntStream stream = Arrays.stream(arr);
    Employee e1 = new Employee(1,"Tom",23,677);
    Employee e2 = new Employee(2,"Tim",55,897);
    Employee[] arr1 = new Employee[]{e1,e2};
    Stream<Employee> employeeStream = Arrays.stream(arr1);
}

方式三：通过Stream的of方法

@Test
public void test03(){
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
}

2.中间操作

筛选与切片

• filter(Predicate p)–接收Lambda，从流中排除某些操作
• limit(n)–截断流，使其元素不超过给定数量
• skip()–跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流
• distinct()–筛选，通过流所生成的元素的hashCode（）和equals（）去除重复元素

public class Test02 {
    @Test
    public void test01(){
        List<Employee> list = EmployeeData.getEmployees();
        list.forEach((e)-> System.out.println(e.toString()));
        System.out.println("复习Lambda表达式");
        list.forEach(System.out ::println);

        //filter(Predicate p)--接收Lambda，从流中排除某些操作
        //Predicate 传入一个对象 返回一个boolean
        System.out.println("-------------查询工资大于6000的人--------------");
        Stream<Employee> stream = list.stream();
        stream.filter(e -> e.getSalary() > 6000).forEach(System.out::println);

        //limit(n)--截断流，使其元素不超过给定数量
        System.out.println("---------测试截断流---------");
        list.stream().limit(3).forEach(System.out::println);

        //skip()--跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流
        System.out.println("--------测试跳过数据----------");
        list.stream().skip(3).forEach(System.out::println);

        //distinct()--筛选，通过流所生成的元素的hashCode（）和equals（）去除重复元素
        System.out.println("--------测试去除重复数据---------");
        list.add(new Employee(1001,"马化腾",34,600.127));
        list.add(new Employee(1001,"马化腾",34,600.127));
        list.add(new Employee(1001,"马化腾",34,600.127));
        list.stream().distinct().forEach(System.out::println);
    }
}