java8新特性

目录

一、Lambda表达式

java内置的四大核心函数式接口

构造器引用

数组引用Function中的Rapply(T t)

方法引用的使用：

二、StreamAPI

创建Stream方式一：通过集合

创建Stream方式二：通过数组

一些常用方法：

筛选与切片

映射

排序

Stream的终止操作

匹配与查找

归约

收集

Optional类（没写啥）

---

一、Lambda表达式

 1.举例：(o1，o2) -> Integer.compare(o1,o2);
 2.格式：
      ->: lambda操作符 或 箭头操作符
      ->左边:lambda形参列表(其实就是接口中的抽象方法的形参列表)
      ->右边:lambda体(其实就是重写的抽象方法的方法体)
 3.Lambda表达式的本质：作为函数式接口的实例化对象
 函数式接口（@FunctionalInterface）：只声明了一个抽象方法（当然也可以自定义函数式接口）

java内置的四大核心函数式接口

消费型接口 Consumer<T>      void accept(T t)
供给型接口 Supplier<T>      T  get()
函数型接口 Function<T,R>    R apply(T t)
断定型接口 Predicate<T>     boolean test(T t)

构造器引用

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

构造器引用
Supplier中的T get
EmpLoyee的空参构造器: Employee()

@Test
    public void test() {
        Supplier<Person> s = new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person();
            }
        };
        System.out.println(s.get());

        System.out.println("****************");

        Supplier<Person> p = () -> new Person();
        p.get();

        System.out.println("****************");

        Supplier<Person> p1 = Person::new;
        p1.get();
    }

数组引用Function中的Rapply(T t)

@Test
    public void test2() {

        Function<Integer, String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

        System.out.println("***********************");

        Function<Integer,String[]> function = String[]::new;
        String[] arr2 = func1.apply(5);
        System.out.println(Arrays.toString(arr2));
    }

方法引用的使用：

1.使用情景：当要传递给Lambda体的操作已经有实现方法了，可以使用方法引用
方法引用使用的要求:要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同!
2.方法引用本质上就是Lambda表达式，都是函数式接口的实例
3.使用格式：  类（或对象）:: 方法名
4.具体分为以下三种情况：
对象::非静态方法
类::静态方法
类::非静态方法

public class MethodQuoteTest {
    /*
    情况一:对象::实例方法
    Consumer中的void accept(T t)
    Printstream中的void println(T t)
     */
    @Test
    public void test() {
        Consumer<String> con = s -> System.out.println(s);
        con.accept("beijing");

        System.out.println("*********************");

        PrintStream out = System.out;
        Consumer<String> con1 = out::println;
        con1.accept("shanghai");
    }

    /*
   情况二:类::静态方法
   Comparator中的int compare(T t1, T t2)
   Integer中的int compare(T t1,T t2)
        */
    @Test
    public void test2() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));

        System.out.println("*******************************");

        Comparator<Integer> com2 = Integer::compareTo;
        System.out.println(com2.compare(21, 12));
    }

    /*
    情况三:类::实例方法（有难度)
    comparator中的int comapre(T t1,T t2)
    String中的int t1.compareTo(t2)
     */
    @Test
    public void test3(){
        Comparator<String> com1 = (t1,t2) -> t1.compareTo(t2);
        System.out.println(com1.compare("abc","abd"));

        System.out.println("****************************");

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

二、StreamAPI

 1. stream关注的是对数据的运算，与CPU打交道
 集合关注的是数据的存储，与内存打交道
 2.
 ①Stream 自己不会存储元素。
 ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream.
 ③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
 3.Stream执行流程
 ①Stream的实例化
 ②一系列的中间操作（过滤、映射、...)
 ③终止操作
 4.说明:
 4.1 一个中间操作链，对数据源的数据进行处理
 4.2一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

创建Stream方式一：通过集合

@Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
//        default Stream<E> stream() :返回一个顺序流
        Stream<Employee> stream = employees.stream();

//      default Stream<E> parallelStream() :返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }

创建Stream方式二：通过数组

@Test
    public void test2() {
        int[] i = new int[]{1,2,4,5,6,7};
        IntStream stream = Arrays.stream(i);

        Employee tom = new Employee(1, "tom");
        Employee jerry = new Employee(2, "jerry");
        Employee[] employees = {tom, jerry};
        Stream<Employee> stream1 = Arrays.stream(employees);


    }

一些常用方法：

筛选与切片

@Test
    public void test() {

        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)—接收Lambda，从流中排除某些元素。
        Stream<Employee> stream = list.stream();//这算是入口
        //查询员工表中工资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);//结束了以后再要用就得重新调用stream()方法。
        System.out.println("************************");

//        limit(n)——截断流,使其元素不超过给定数量。
        list.stream().limit(2).forEach(System.out::println);
        System.out.println("************************");

//      skip(n)——跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("************************");

//      distinct()——筛选，通过流所生成元素的 hashCode(和equals()去除重复元素
        list.add(new Employee(1, "常海玉", 12, 80000));
        list.add(new Employee(1, "常海玉", 12, 80000));
        list.add(new Employee(1, "常海玉", 12, 80000));
        list.stream().distinct().forEach(System.out::println);
    }

映射

@Test
    public void test2() {
//        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

        //练习1：获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
        System.out.println();
        //练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest2::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
        System.out.println();

//        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest2::fromStringToStream);
        characterStream.forEach(System.out::println);
    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str) {//aa
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

排序

@Test
    public void test3() {
//        sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 45, 5, 6, 6, 342, 3425, 6, 643, 5);
        list.stream().sorted().forEach(System.out::println);

//        sorted( Comparator com)—定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted(
                (e1, e2) -> {
                    int compare = Integer.compare(e1.getAge(), e2.getAge());
                    if (compare != 0) {
                        return compare;
                    } else {
                        return Double.compare(e1.getSalary(), e2.getSalary());
                    }
                })
                .forEach(System.out::println);
    }
}

Stream的终止操作

匹配与查找

@Test
    public void test(){
        List<Employee> list = EmployeeData.getEmployees();
//allMatch(Predicate p)——检查是否匹配所有元素。
// 练习:是否所有的员工的年龄都大于18
        boolean allMatch = list.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

//anyMatch(Predicate p)——检查是否至少匹配一个元素。
// 练习:是否存在员工的工资大于10000
        boolean b = list.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(b);

// noneMatch(Predicate p)——检查是否 没有 匹配的元素。
// 练习:是否 不存在 员工姓"雷”
        boolean b1 = list.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(b1);

//findFirst——返回第一个元素
        Optional<Employee> first = list.stream().findFirst();
        System.out.println(first);

//findAny——返回当前流中的任意元素count——返回流中元素的总个数
        Optional<Employee> any = list.parallelStream().findAny();
        System.out.println(any);

//count——返回流中元素的总个数
        long count = list.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);


//max(Comparator c)—返回流中最大值
// 练习:返回最高的工资∶
        Stream<Double> doubleStream = list.stream().map(e -> e.getSalary());
        Optional<Double> max = doubleStream.max((e1, e2) -> e1.compareTo(e2));
        System.out.println(max);


//min(Comparator c)—返回流中最小值
// 练习:返回最低工资的员工
        Optional<Employee> min = list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);

//forEach(Consumer c)—一内部迭代
        list.stream().forEach(System.out::println);//StreamAPI内部的forEach

        list.forEach(System.out::println);//集合自己的forEach
    }

归约

@Test
    public void test2(){
//        reduce(T identity,Binary0perator)—可以将流中元素反复结合起熟，得到一个值。返回T
//        练习1:计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);

//        reduce(Binaryoperator)—可以将流中元素反复结合起来，得到一个值。返回Optional<T>
//        练习2:计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
//        Optional<Double> reduce1 = salaryStream.reduce(Double::sum);
        Optional<Double> reduce1 = salaryStream.reduce((d1, d2)->d1+d2);

        System.out.println(reduce1);
    }

收集

 @Test
    public void test3(){
//collect(collector c)—将流转换为其他形式。接收一个 collector接口的实现，用于给Stream中元素做汇总的方泛
//练习1:查找工资大于6e0日的员工，结果返回为一个List或Set(无序的）

        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Employee> employeeStream = employees.stream().filter(employee -> employee.getSalary() > 6000);
        List<Employee> collect = employeeStream.collect(Collectors.toList());
        collect.forEach(System.out::println);

        System.out.println();

        Stream<Employee> employeeStream1 = employees.stream().filter(employee -> employee.getSalary() > 6000);
        Set<Employee> collect1 = employeeStream1.collect(Collectors.toSet());
        collect1.forEach(System.out::println);
    }

Optional类（没写啥）

Optional.of(T t) :创建一个 Optional实例，t必须非空;
Optional.empty() :创建一个空的Optional实例
Optional.ofNullable(T t) : t可以为null