23、java8新特性（Lambda表达式、函数式接口、方法引用、构造器引用、Stream API、optional类）

目录

== 一、Lambda表达式==

二、函数时（Functional）接口

三、方法引用与构造器引用

四、强大的Stream API

五、Optional类

一、Lambda表达式

Lanmbda表达式举例1

Lanmbda表达式举例2

语法解释

1、举例：（o1,o2） -> Integer.compare(o1,o2);
2、格式
    ->:Lambda操作符 
    -> 的左边：Lambda的形参列表（其实就是接口中的抽象方法的形参列表）
    -> 的右边：Lambda体（其实就是重写的抽象方法的方法体，是抽象方法的
    实现逻辑，也即Lambda 表达式要执行的功能）

Lambda表达式的使用

代码演示

@Test
    public void test1(){
        //语法格式一：无参，无返回值
        Runnable runnable = () -> {
            System.out.println("我爱北京故宫");
        };
        runnable.run();

        //语法格式二：Lambda 需要一个参数，但是没有返回值
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("重庆火锅");

        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("抄手");

        //语法格式三：数据类型可以省略，因为可由编译器推断得到（类型推断）
        Consumer<String> con3 = (s) -> {
            System.out.println(s);
        };
        con3.accept("小面");

        //语法格式四：Lambda 若只需要一个参数，参数的小阔号可以从省略
        Consumer<String> con4 = s -> {
            System.out.println(s);
        };
        con4.accept("大米");

        //语法格式五：Lambda 需要两个或两个以上的参数，多条执行语句，并且可以有返回值
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };

        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };


        //语法格式六： 当Lambda体只有一条语句时，return与大括号若有，都可以省略

        Comparator<Integer> com3 = (o1,o2) -> o1.compareTo(o2);

        Runnable runnable2 = () -> System.out.println("我爱北京故宫");
        runnable2.run();
    }

总结

• Lambda表达式的本质：作为接口的实例（要求接口时函数式接口）
• ->左边：Lambda形参列表的参数u类型可以省略（类型推断）：如果Lambda形参列表只有一个参数，他的一对括号（）可以省略，有多个参数就不要省略了
• ->右边：Lambda体：一般应该使用一对大括号{}进行包裹，如果Lambda体只有一条执行语句，return和大括号{}可以省略

二、函数时（Functional）接口

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

Lambda表达式只能对函数式接口使用

注解@FunctionalInterface

自定义函数式接口

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

其他接口

使用Lambda表达式后

三、方法引用与构造器引用

方法引用使用的要求：

• 接口中的抽象方法的形参列表和返回值的类型，与方法引用的方法的形参列表和返回值的类型相同(针对情况1和情况2)

方法引用的使用

• 1、使用情景：当要传递个Lambda体的操作，已经有实现的方法了，就可以使用方法引用了

• 2、方法引用，本质上就是Lambda表达式，而Lambda表达式，作为函数式接口的实例，所以方法引用，也式函数式接口的实例
  

• 3、使用格式：

    类（或对象）：：方法名
    调用者          要调用的方法

4、具体分为如下三种情况

• 情况1 对象：：非静态方法

Consumer 中的 void accept(T t)

PrintStream 中的 void println(T t)

        //使用Lambda表达式
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");

        //使用方法引用
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("南京");

Suplier 中的 T get()

Employee 中的 String getName()

//使用Lambda表达式
        Employee emp = new Employee(1001,"Tom");
        Supplier<String> sup1 = () -> "东京"+emp.getName();
        System.out.println(sup1.get());

        //使用方法引用
        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());

• 情况2 类：：静态方法

Comparator中的int compara(T t1,T t2)

Integer 中的 int compara(T t1,T t2)

        //使用Lambda表达式
        Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);

        //使用方法引用
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 3));

Funcation 中的 Rapply(T t)

Math 中的Long round(Double d)

        //使用Lambda表达式
        Function<Double,Long> func1 = d -> Math.round(d);

        //使用方法引用
        Function<Double,Long> func2 = Math :: round;

• 情况3 类：：非静态方法(有难度)

Compaare 中的 int compare(T t1,T t2)

String 中的 int t1.compareTo(t2)

        //使用Lambda表达式
        Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc","abd"));

        //使用方法引用
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abc","abd"));

BiPredicate中的boolean test(T t1,T t2)

String 中的 boolean t1.equals(t2)

//使用Lambda表达式
        BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc","abd"));

        //使用方法引用
        BiPredicate<String,String> pre2 = String::equals;
        System.out.println(pre2.test("abc","abd"));

Function中的R apply(T t)

Employee中的String getName()

//使用Lambda表达式
        Employee employee = new Employee(1001, "Tom", 23, 2000);

        Function<Employee,String> func1 = e -> e.getName();
        System.out.println(func1.apply(employee));

        //使用方法引用
        Function<Employee,String> func2 = Employee::getName;
        System.out.println(func2.apply(employee));

构造器引用与项目引用的使用

和方法引用类似.,函数式接口的抽象方法的形参列表和构造器的形参列表一致

抽象方法的返回值类型即为构造器的类型

• 实例一

Suppiler 中的E get()

Employee 的空参构造器: Employee()

//原版写法
        Supplier<Employee> sup1 = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        //Lambda表达式
        Supplier<Employee> sup2 = () -> new Employee();

        //构造器引用
        Supplier<Employee> sup3 = Employee::new;
        System.out.println(sup2.get());

• 举例二

Function 中的 get(T t)

Employee中的构造器 Employee(int id);

//Lambda表达式
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

        //构造器引用(id不用写，)
        Function<Integer,Employee> func2 = Employee::new;

• 举例三

BiDunction 中的 apply(T t,U u)

Employee中的构造器Employee(int id, String name)

// Lambda表达式
        BiFunction<Integer,String,Employee> biFunc1 = (id,name) -> new Employee(id,name);
        Employee employee2 = biFunc1.apply(1002,"Tom");
        System.out.println(employee2);

        //构造器引用
        BiFunction<Integer,String,Employee> biFunc2 = Employee::new;
        Employee employee3 = biFunc2.apply(1003,"Lucy");

数组引用

可以把数组看作式一个特殊的类,则写法与构造器一致

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

        //数组引用
        Function<Integer,String[]> func2 = String[] ::new;
        String[] arr2 = func2.apply(6);
        System.out.println(Arrays.toString(arr2));

四、强大的Stream API

1、创建Stream(Stream的实例化)

方式一:通过集合

//通过集合
        List<Employee> employees = EmployeeData.getEmployees();
        //default Stream<E> stream() : 返回一个顺序流
        Stream<Employee> stream = employees.stream();

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

方式二:通过数组

//通过数组
        int[] arr = new int[]{1,2,3,4,5,6,7};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流

        IntStream stream1 = Arrays.stream(arr);

        Employee employee = new Employee();

方式三:通过Stream类的of()方法![

![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mE3oLTFp-1611071288887)(806F967243EB4D7BA762251B20FF05FD)]](https://img-blog.csdnimg.cn/2021012000014039.png)

//通过of()方法
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);

方式四:创建无限流

//通过of()方法
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);

        //创建无限流

        //迭代
        //遍历前10 个偶数
        Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);
        //生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    

2、Stream的中间操作

2.1 筛选与切片

@Test//1、筛选与切片
    public void test2(){
        List<Employee> list = EmployeeData.getEmployees();
        Stream<Employee> stream = list.stream();


        //filter():查询员工表中的薪资大于7000的员工
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

        //limit():只要前n个元素
        list.stream().limit(3).forEach(System.out::println);

        //skip():跳过前n个元素
        list.stream().skip(3).forEach(System.out::println);

        //distinct():除去相同的元素（equals()和hashCode()判断）
        list.stream().distinct().forEach(System.out::println);
    }

2.2 映射

@Test//2、映射
    public void test3(){
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee", "ff");
        List<Employee> employees = EmployeeData.getEmployees();
        //map():对每个数据进行运算，得出新的数据
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::print);
        //练习1：获取员工姓名长度大于3的员工的姓名
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3);

        //flatMap():先map()，再把每个流连起来变成一个流(方法的返回值必须是Stream类型)
        //练习2：
        //map()：按照正常方法得到的是地址
        list.stream().map(StreamAPITest::fromStringToStream).forEach(s -> s.forEach(System.out::print));

        list.stream().flatMap(StreamAPITest::fromStringToStream).forEach(System.out::print);
    }

2.3 排序

@Test//3、排序
    public void test5(){
        List<Integer> list = Arrays.asList(15,34,53,46,76,35);
        //如果要打其他内容，可以这么写
        //sorted():自然排序
        list.stream().sorted().forEach(s -> System.out.print(s+" "));

        //sorted(Comparator com):定制排序
        list.stream().sorted((i1,i2) -> -Integer.compare(i1,i2)).forEach(s -> System.out.print(s + " "));
    }

3、Stream的终止操作

3.1 匹配与查找

@Test//1、匹配与查找
    public void test6(){
        List<Integer> list = Arrays.asList(15,34,53,46,76,35);
        //allMatch():检查所有元素是否符合条件
        System.out.println(list.stream().allMatch(s -> s > 5));

        //anyMatch():检查是否存在一个元素 符合条件
        System.out.println(list.stream().anyMatch(s -> s > 75));

        //noneMatch():allMatch()取反
        System.out.println(list.stream().noneMatch(s -> s > 5));

        //max():按其中排序的最后一个
        System.out.println(list.stream().max(Integer::compare));
        //min():按其中排序的第一个

        //forEach(): 迭代器
    }

3.2 归约

@Test//2、归约
    public void test7(){
        List<Integer> list = Arrays.asList(15,34,53,46,76,35);
        //reduce(T iden, BinaryOperator b):可以将流中元素反复结合起来，得到一个值。返回 T
        //练习1：计算list的和 再  +10(sum方法正好是两个参数，可以用方法啊引用（BiFunction接口）)
        System.out.println(list.stream().reduce(10, Integer::sum));
        System.out.println(list.stream().reduce(10, (i1, i2) -> i1 + i2));

        //reduce(BinaryOperator b):可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
    }

3.3 收集

@Test//3、收集
    public void test8(){
        List<Integer> list = Arrays.asList(15,34,53,46,76,35);

        //collect(Collector c):把流转换为其他类型
        Set<Integer> set = list.stream().filter(i -> i > 50).collect(Collectors.toSet());
    }

强大的Stream API : Collectors

五、Optional类

Optional类的创建

使用

代码演示

@Test
public void test1() {
	Boy b = new Boy("张三");
	Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
	// 如果女朋友存在就打印女朋友的信息
	opt.ifPresent(System.out::println);
}
@Test
public void test2() {
	Boy b = new Boy("张三");
	Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
	// 如果有女朋友就返回他的女朋友，否则只能欣赏“嫦娥”了
	Girl girl = opt.orElse(new Girl("嫦娥"));
	System.out.println("他的女朋友是： " + girl.getName());
}

@Test
public void test3(){
	Optional<Employee> opt = Optional.of(new Employee("张三", 8888));
	//判断opt中员工对象是否满足条件，如果满足就保留，否则返回空
	Optional<Employee> emp = opt.filter(e -> e.getSalary()>10000);
	System.out.println(emp);
}
@Test
public void test4(){
	Optional<Employee> opt = Optional.of(new Employee("张三", 8888));
	//如果opt中员工对象不为空，就涨薪10%
	Optional<Employee> emp = opt.map(e ->
	{e.setSalary(e.getSalary()%1.1);return e;});
	System.out.println(emp);
}