Java8新特性学习笔记-CSDN博客

本文链接：https://blog.csdn.net/huhuhutony/article/details/119795424

Lambda表达式

2021-06-11

package xyz.guawaz.java8;

/**
 * @auther guawaz
 * @create 2021-06-11-10:29
 *
 *Lambda表达式的使用
 *
 * 1.举例：(o1,o2) -> Integer.compare(o1,o2)
 * 2.格式：
 *          -> :lambda操作符或箭头操作符
 *          ->左边：lambda形参列表（其实就是接口中抽象方法的形参列表）
 *          ->右边：lambda体 (其实就是重写的抽象方法的方法体)应该使用一对{}括起来，如果lambda体只有一条执行语句（可能是return语句），省略{}和return
 * 3.lambda表达式的使用：(分6种情况)
 *
 *  总结：
 *      ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，则()也可以省略
 *      ->右边：lambda体 应该使用一对{}括起来，如果lambda体只有一条执行语句（可能是return语句），省略{}和return
 *
 *
 * 4.lambda表达式的本质：接口的实例 （要求接口为函数式接口）
 * 5.函数式接口：只包含一个抽象方法的接口  (@FunctionalInterface)
 *  举例：Runnable、Comparator、java.util.function
 * 6.以前用匿名实现类表示的现在都可以用lamnbda表达式来写
 */

函数式（Functional）接口

public class LambdaTest {

    @Test
    public void test1(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double d) {
                System.out.println("口渴了，去天上人间买了瓶矿泉水，价格为：" + 500);
            }
        });
    }
    @Test
    public void test2(){
        happyTime(500, money -> System.out.println("口渴了，去天上人间买了瓶矿泉水，价格为：" + money));

    }
    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }

    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","东京","上海");
        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });

        List<String> filterStrs1 = filterString(list, s -> s.contains("京") );
        
        System.out.println(filterStrs);
        System.out.println(filterStrs1);
    }

    public List<String> filterString (List<String> list, Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list){
            if (pre.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }
}

方法引用与构造器引用

package xyz.guawaz.java8;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * @auther guawaz
 * @create 2021-06-11-16:08
 *
 * 方法引用的使用
 * 1.使用情境：当要传递给lambda体的操作，已经有实现的方法了，可以使用方法引用
 * 2.方法引用本质山就是lambda表达式
 * 3.使用格式：   类（或对象）::方法名
 * 4.具体分为以下三种格式
 *  情况1    对象 ::非静态方法
 *  情况2    类  :: 静态方法
 *  情况3    类  :: 非静态方法
 * 5.情况1和情况2要求接口中抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同
 *
 */
public class FangFaYinYong {


    //情况一：对象::实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)

    @Test
    public void test1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");

        Consumer<String> con2 = System.out::println;
        con2.accept("上海");
    }

    //Supplier中的T get()
    //Employee中的String getName()
//    @Test
//    public void test2(){
//        Employee emp = new Employee(1001,"TOM",23,5600);
//        Supplier<String> sup1 = () -> emp.getName();
//        System.out.println(sup1.get());
//
//        Supplier<String> sup2 = emp::getName;
//        System.out.println(sup2.get());
//    }

    //情况二：类::静态方法
    //Comparator中的int compara(T t1, T t2)
    //Integer中的int compare(T t1, T t2)

    @Test
    public void test3(){
        Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));

        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(13, 31));
    }

    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4(){
        Function<Double,Long> func = 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("sbc", "acb"));

        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("sbc", "acb"));
    }
}


    /*
    和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
    抽象方法的返回值类型即为构造器所属的类的类型

    */
    
    //构造器引用
    //Supplier中的Tget()
    //Employee的空参构造器Employee
    @Test
    public void test6(){
        Supplier<Employee> sup = () -> new Employee();
        Supplier<Employee> sup1 = Employee::new;
    }
    //Function中的R apply(T t)
    @Test
    public void test7(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Function<Integer,Employee> func2 = Employee :: new;
    }

强大的StreamAPI

Stream是 Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作
，可以执行非常复杂的查找、过滤和映射数据等操作。使用StreamAPI对集合数据
进行操作，就类似于使用SQL执行的数据库查询。也可以使用StreamAPI来并行执行操作。
简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了
，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。

Stream和 Collection集合的区别:Collection是一种静态的内存数据结构，
而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。

    //方式一：通过集合
    @Test
    public void test(){
        List<Employee> employees = EmployeeData.getEmployees();
        
        //default Stream<E> stream()  返回一个顺序流
        Stream<Employee> stream = employees.stream();
        //default Stream<E> parallelStream()  返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }
    //方式二：通过数组
    @Test
    public void test1(){
        int[] arr = new int[]{1,2,3,4,5,6,7};
        //通过调用Arrays类的static <T> Stream<T> stream(T[] array) 返回一个流
        IntStream Stream = Arrays.stream(arr);

    }
    //方式三：通过Stream.of()
    @Test
    public void test2() {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    }