2021-07-27

方法引用

函数式接口
接口中只与一个必须被重写的抽象方法
@FunctionalInterface

四大内置函数式接口:
1.消费型接口 Consumer
void accept(T t) --> 有来无回,有参数没有返回值
2.供给型接口 Supplier
T get()
3.函数型接口 Function<T,R>
R apply(T t)
4.段言型接口 Predicate
boolean test(T t)

方法引用
当lambda体的实现,是通过调用其他方法实现的,可以通过方法引用的方式实现简化Lambda表达式

是lambda表达式的另外一种表现形式,简化Lambda表达式 ()->{}

语法: (:😃
对象::成员方法名
1)lambda体的实现是否是通过调用了另外一个方法实现的 --> √
2)内部所引用方法的返回值是否与lambda的返回值保持一致 --> √
类名::静态方法名

​ 1)lambda体的实现是否是通过调用了另外一个方法实现的 --> √

​ 2)内部所引用方法的返回值是否与lambda的返回值保持一致 --> √

​ 类名::成员方法名

​ 1)lambda体的实现是否是通过调用了另外一个方法实现的 --> √

​ 2) 内部所引用方法的返回值与lambda的返回值相同
​ lambda参数列表的第一个参数作为内部引用成员方法的对象存在
lmabda参数列表的第二个参数开始(如果有的话)作为内部引用方法的参数列表

例：

import java.io.PrintStream;
import java.util.Comparator;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;

public class Class002_FunctionQuite {
    public static void main(String[] args) {
        test3();
    }
    //类名::成员方法名
    public static void test3(){
        //BiPredicate<String,String> pre = (x,y)-> x.equals(y);
        /*
             分析:  通过类名::成员方法名 简化lanbda结构
                1)lambda体的实现是否是通过调用了另外一个方法实现的  --> √
                2) 内部所引用方法的返回值与lambda的返回值相同
                   lambda参数列表的第一个参数作为内部引用成员方法的对象存在
                   lmabda参数列表的第二个参数开始(如果有的话)作为内部引用方法的参数列表
         */
        BiPredicate<String,String> pre = String::equals;
        System.out.println(pre.test("张三","张三封"));;
    }


    //类名::静态方法名
    public static void test2(){
        //求两个数中最大的值
        //BiFunction<Integer,Integer,Integer> function = (x,y)-> Math.max(x,y);
        /*
             分析:
                1)lambda体的实现是否是通过调用了另外一个方法实现的  --> √
                2)内部所引用方法的返回值是否与lambda的返回值保持一致 --> √
         */
        BiFunction<Integer,Integer,Integer> function = Math::max;

        System.out.println(function.apply(100,101));;

        //Comparator<Integer> com  = (x,y) -> {return Integer.compare(x,y);};
        /*
             分析:
                1)lambda体的实现是否是通过调用了另外一个方法实现的  --> √
                2)内部所引用方法的返回值是否与lambda的返回值保持一致 --> √
         */
        Comparator<Integer> com  = Integer::compareTo;

        System.out.println(com.compare(18,18));;

    }

    //对象::成员方法名
    public static void test1(){
        List<Integer> list = List.of(1,2,3,4,5);

        list.forEach(x->{
            System.out.println(x);
        });

        PrintStream ps = System.out;

        list.forEach(x->{
            ps.println(x);
        });
        /*
            分析:
                1)lambda体的实现是否是通过调用了另外一个方法实现的  --> √
                2)内部所引用方法的返回值是否与lambda的返回值保持一致 --> √
         */
        list.forEach(ps::println);
        list.forEach(System.out::println);
    }
}

构造器引用–> 类名：：new

数组引用–> 类型[]：：new

import java.util.Arrays;
import java.util.function.Function;
import java.util.function.Supplier;

public class Class003_FunctionQuite {
    public static void main(String[] args) {
        //构造器引用
        //Supplier<Employee> sup = ()-> new Employee();
        //1) lambda体中创建了对象.引用了某一个构造器  √
        //2) 所引用的构造器的参数列表是否与lambda的参数列表一致
           //创建的对象作为lambda返回值
        Supplier<Employee> sup = Employee::new;
        System.out.println(sup.get());

        Function<String,Employee> fun = s -> new Employee(s);
        fun = Employee::new;
        System.out.println(fun.apply("yinwei"));

        //数组引用
        Function<Integer,Integer[]> fun2 = i -> new Integer[i];
         fun2 =Integer[]::new;

        System.out.println(Arrays.toString(fun2.apply(5)));
    }
}

class Employee{
    private String  name;
    private int num;

    public Employee() {
    }

    public Employee(String name) {
        this.name = name;
    }

    public Employee(String name, int num) {
        this.name = name;
        this.num = num;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", num=" + num +
                '}';
    }
}

Stream流

Stream流:
根据数据源所产生的的元素序列
数据源: 集合,数组 —> 侧重点在数据的存储
stream流: -->关注数据的计算

注意:
1.流本身不能存储数据
2.流不能修改数据源中的数据
3.流是一次性的流,流是式操作的每一步都会返回一个持有结果的新流
4.延迟执行|惰性加载 : 当不进行终止行为时候,不会执行流式中间操作

过程:
1.获取|创建stream
2.流式中间操作
3.终止行为(返回的结果不在是stream)

1.获取|创建stream

public static void main(String[] args) {
        //1.Collection--> stream
        List<Integer> list = new ArrayList<>();
        //顺序流
        Stream<Integer> stream = list.stream();
        //并行流
        Stream<Integer> stream2 = list.parallelStream();

        System.out.println(stream2);

        //2) Arrays.stream(array)
        Stream stream3 = Arrays.stream(new String[]{"1"});
        System.out.println(stream3);

        //3)Stream.of(数据1,数据2,数据3...)
        Stream stream4 = Stream.of("a","b");
        stream4.forEach(System.out::println);

        //4)Stream.of(数组)
        Stream stream5 =  Stream.of(new String[]{"abc","bcd"});
        stream5.forEach(System.out::println);

    }

2.流式中间操作

​ a.筛选和切片–>filter()、limit()、skip()、distinct()……

​ b.排序–> 1.sorted(Comparable)-自然排序

​ 2.sorted(Comparator)-定制排序

import com.yjx.entity.Employee;
import java.util.List;
import java.util.stream.Stream;

public class Class02_Stream {
    private static List<Employee> list=List.of(
            new Employee(101,"张三",18,1111.555),
            new Employee(103,"李四",19,3111.555),
            new Employee(101,"张三",18,1111.555),
            new Employee(102,"赵王",16,2111.555),
            new Employee(104,"王六",19,5111.555),
            new Employee(106,"老八",20,4111.555),
            new Employee(105,"啤酒",18,6111.555)
    );

    public static void main(String[] args) {
        //获取|创建流
        Stream<Employee> stream1=list.stream();
        //操作流
        Stream<Employee> stream2=stream1
                .filter(e->{
                    //System.out.println("正在筛选");
                    return e.getAge()>=18;})
                .limit(5)
                .skip(1)
                .distinct()
                .sorted()
                //.sorted((x,y)->Double.compare(x.getPrice(),y.getPrice()));
        ;
        //终止行为
        stream2.forEach(System.out::println);
    }
}

map()与flatMap()

    public static void main(String[] args) {
        //获取|创建流

        Stream<Employee> stream1=list.stream();
        //操作流
        //1) 获取员工姓名的流
        Stream stream2=stream1.map((employee)->{return employee.getName();})
            .distinct();
        //终止行为
        stream2.forEach(System.out::print);
        System.out.println();


        List<String> list = List.of("aaa","bbb","ccc");
        Stream<Character> stream3=list.stream()
                .flatMap(Class03_Stream_map::getCharacterStream);
        stream3.forEach(System.out::println);
        //map
        List<Stream> list1=list.stream()
                .map(Class03_Stream_map::getCharacterStream)
                .collect(Collectors.toList());
        for (Stream st :
                list1) {
            st.forEach(System.out::println);
        }
    }

3.终止行为

​ a. 查找与匹配

​ b. 收集（了解）

public void test1() {
// allMatch-检查是否匹配所有元素
boolean b1 = emps.stream()
.allMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println(b1);
// anyMatch-检查是否至少匹配一个元素
boolean b2 = emps.stream()
.anyMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println(b2);
// noneMatch-检查是否没有匹配所有元素
boolean b3 = emps.stream()
.noneMatch((e) -> e.getStatus().equals(Status.OTHER));
System.out.println(b3);
// findFirst-返回第一个元素
// 需求：按工资排序，获取第一个员工信息
Optional<Employee> op1 = emps.stream()
.sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
.findFirst();
System.out.println(op1.get());
// findAny-返回当前流中的任意元素
// 需求：找一个空闲状态的员工，添加到开发团队中
Optional<Employee> op2 = emps.parallelStream()// 并行流-多条线程进行，谁先找到就是
谁
.filter((e) -> e.getStatus().equals(Status.FERR))
.findAny();
System.out.println(op2.get());
// count-返回流中元素的总个数
Long count = emps.stream().count();
System.out.println(count);
// max-返回流中最大值
// 需求：获取工资最高的员工信息
Optional<Employee> op3 = emps.stream()
.max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(op3.get());
// min-返回流中最小值
// 需求：获取公司中工资最少员工的工资
Optional<Double> op4 = emps.stream()
.map(Employee::getSalary)
.min(Double::compare);
System.out.println(op4.get());
}

收集-将流转换为其他形式，接收一个Collertor接口的实现，用于给Stream中元素做汇总的方法

// 需求：获取当前公司所有员工的姓名添加到集合中
// List-把流中所有元素收集到List中
List<String> list = emps.stream()
.map(Employee::getName)
.collect(Collectors.toList());
list.forEach(System.out::println);

// Set-把流中所有元素收集到Set中，删除重复项
Set<String> set = emps.stream()
.map(Employee::getName)
.collect(Collectors.toSet());
set.forEach(System.out::println);

// Map-把流中所有元素收集到Map中，当出现相同的key时会抛异常
Map<String, Integer> map = emps.stream()
.collect(Collectors.toMap(Employee::getName, Employee::getAge));
System.out.println(map);


// 员工总数
Long count = emps.stream()
.collect(Collectors.counting());
System.out.println(count);
// 工资平均数
Double avg = emps.stream()
.collect(Collectors.averagingDouble(Employee::getSalary));
System.out.println(avg);
// 工资总和
Double sum = emps.stream()
.collect(Collectors.summingDouble(Employee::getSalary));
System.out.println(sum);
// 工资最大值的员工
Optional<Employee> op = emps.stream()
.collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(),
e2.getSalary())));
System.out.println(op.get());

注意：
1、Stream自己不会存储元素·
2、Stream不会改变源对象。相反，会返回一个持有结果的新Stream。

​ 3、Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行。

Oracle Database

oracle XE安装与卸载，测试

数据库了解