java8完全解读一

Posted 2020-10-19 gxl1995

java8完全解读

java8完全解读
前言
java8的一些新特性
1.为什么要用java8?
1.1首先想到的逻辑应该是如下
1.2使用策略模式来解这个问题
1.3使用策略模式和内部类来解决问题
1.4使用策略模式和lambda方式来解决这个问题
1.5使用stream流来解决这个问题
2.lambda基础语法
2.1 无参数无返回值
2.2有一个参数，并且无返回值
2.3 若只有一个参数，小括号可以省略不写
2.4 有两个以上的参数，有返回值，并且 Lambda 体中有多条语句函数体需要用{}
2.5 若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
2.6 Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
3.函数式接口
3.1自定义函数式接口
3.2内置四大核心函数式接口
Consumer : 消费型接口 (只传递参数，不返回参数)
Supplier : 供给型接口(无参，但返回结果)
Function : 函数型接口(传入一个类型参数，返回一个类型的结果)
Predicate : 断言型接口 （传入一个类型参数，返回一个boolean类型的结果）
其他重要函数
4.方法引用和构造器引用
4.1方法引用
4.2构造器引用
4.3数组引用

前言

java8已经发布很久了，本人在学完java8后感觉java8确实好用，本文是根据尚硅谷java8视频整理而来,文章徐徐渐进容易理解。

java8的一些新特性

• Lambda 表达式
• 函数式接口
• 方法引用与构造器引用
• Stream API
• 接口中的默认方法与静态方法
• 新时间日期API
• 其他新特性

其中最重要的就是Lambda和Stream的使用

1.为什么要用java8?

这里通过一个小案例来讲解用java8的方便之处

• 假如有这么一道面试题，求公司员工中年龄>35岁的的信息和薪水>5000的员工信息?

员工类(Employee.clsss)

package java8.whytostudylamdba;

public class Employee {
    private String name;
    private int age;
    private double sal;
    public Employee(String name, int age, double sal) {
        this.name = name;
        this.age = age;
        this.sal = sal;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getSal() {
        return sal;
    }
    public void setSal(double sal) {
        this.sal = sal;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ", sal=" + sal +
                ‘}‘;
    }
}

给出的员工表

List<Employee> employees= Arrays.asList(
            new Employee("张三",18,3000.00),
            new Employee("李思思",25,3500.00),
            new Employee("王五",30,6000.00),
            new Employee("赵六",36,4500.00),
            new Employee("天琪",50,6000.00),
            new Employee("王八",18,38000.00)
            );

好了下面开始写逻辑

1.1首先想到的逻辑应该是如下

public List<Employee> filterEmpByAge(List<Employee> employeeList) {
        List<Employee> emps = new ArrayList<>();
        for (Employee e:employeeList) {
            if (e.getAge() > 35) {
                emps.add(e);
            }
        }
        return emps;
    }
    public List<Employee> filterEmpBySal(List<Employee> employeeList){
        List<Employee> emps = new ArrayList<>();
        for (Employee e:employeeList) {
            if (e.getSal()>5000) {
                emps.add(e);
            }
        }
        return emps;
    }
    @Test
    public void test2(){
        List<Employee> employees = filterEmpByAge(this.employees);
        for (Employee e : employees) {
            System.out.println(e);
        }
        System.out.println("---------");
        List<Employee> employees1 = filterEmpBySal(this.employees);
        for (Employee e : employees1) {
            System.out.println(e);
        }
    }

这个解决方法肯定是可以的，但是这个方法是人都可以想到，你能用这个解决方法上交吗?肯定不行，下面进行优化.

1.2使用策略模式来解这个问题

我们主要是对员工的年龄和工资进行判断,所以需要的是一个传入员工，返回boolean类型的方法,策略接口MyFilter

public interface MyFilter<T> {
    boolean filter(T t);
}

过滤年龄类(FilterByAge.class)

public class FilterByAge implements MyFilter<Employee> {
    @Override
    public boolean filter(Employee employee) {
        return employee.getAge()>35;
    }
}

过滤薪水类(FilterBySal.class)

public class FilterBySal implements MyFilter<Employee> {
    @Override
    public boolean filter(Employee employee) {
        return employee.getSal()>5000;
    }
}

使用策略模式解决这个问题

public List<Employee> filterEmp(List<Employee> employeeList, MyFilter<Employee> filter) {
        List<Employee> emps = new ArrayList<>();
        for (Employee e:employeeList) {
            if (filter.filter(e)) {
                emps.add(e);
            }
        }
        return emps;
    }
    @Test
    public void test3(){
        List<Employee> emps = filterEmp(employees, new FilterByAge());
        for (Employee e : emps) {
            System.out.println(e);
        }
        System.out.println("-------------");
        List<Employee> emps1 = filterEmp(employees, new FilterBySal());
        for (Employee e : emps1) {
            System.out.println(e);
        }
    }

这个方法和上个方法比使用了策略模式，肯定要比上一个方法好，但是每实现一个条件就新建一个类继承MyFilter好像有点不太好，这时想到了内部类的实现方式来解决这个缺点.

1.3使用策略模式和内部类来解决问题

上面的MyFilter接口代码不用动,两个实现类的可以删掉了,使用上面的public List<Employee> filterEmp(List<Employee> employeeList, MyFilter<Employee> filter)方法，以内部类形式实现。

@Test
    public void test4(){
        List<Employee> emp1 = filterEmp(this.employees, new MyFilter<Employee>() {
            @Override
            public boolean filter(Employee employee) {
                return employee.getAge() > 35;
            }
        });
        for (Employee e : emp1) {
            System.out.println(e);
        }
        System.out.println("------------");
        List<Employee> emp2 = filterEmp(this.employees, new MyFilter<Employee>() {
            @Override
            public boolean filter(Employee employee) {
                return employee.getSal() > 5000;
            }
        });
        for (Employee e : emp2) {
            System.out.println(e);
        }
    }

这个比上面的方式更进一步，如果没有lambda这个方式已经是很好的了，下面就开始我们今天的重头戏:使用lambda方式来对上面代码进行再次优化

1.4使用策略模式和lambda方式来解决这个问题

和1.3中的方法一样，不用变什么，就是在调用filterEmp方法时使用labmda表达式

@Test
    public void test5(){
        List<Employee> em1 = filterEmp(this.employees, (e) -> e.getAge() > 35);
        em1.forEach(System.out::println);
        System.out.println("----------");
        List<Employee> em2 = filterEmp(this.employees, (e) -> e.getSal()>5000);
        em2.forEach(System.out::println);//1.8方法
    }

看到没有,对于内部类,使用lambda表达式是一件很轻松的事,现在看不懂?没事后面会说。对应优化做到这种地步，已经无法再优化了，可以使用这种方式提交答案。下面再介绍一种更加新的方式来解决这个问题.

1.5使用stream流来解决这个问题

stream流是1.8新增的，在Collection类中有个stream的静态方法，所以所有集合都可以使用stream流.下面这个方法使用，前面什么方法都不要，假如你刚看到这个题，只有Employee类和相应的List集合数据.

@Test
    public void test6(){
        employees.stream()
                .filter((e)->e.getAge()>35)
                .forEach(System.out::println);
        System.out.println("----------");
        employees.stream()
                .filter((e) -> e.getSal() > 5000)
                .forEach(System.out::println);
    }

可以看到非常容易就解决了上面的问题，是不是很强大，为什么学java8，这就是其中之一的理由.

2.lambda基础语法

Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符,箭头操作符将 Lambda 表达式拆分成两部分：

• 左侧：Lambda 表达式的参数列表
• 右侧：Lambda 表达式中所需执行的功能，即Lambda体

2.1 无参数无返回值

() -> System.out.println("Hello Lambda!");

2.2有一个参数，并且无返回值

(x) -> System.out.println(x)

2.3 若只有一个参数，小括号可以省略不写

x -> System.out.println(x)

2.4 有两个以上的参数，有返回值，并且 Lambda 体中有多条语句函数体需要用{}

Comparator<Integer> com = (x, y) -> {
         System.out.println("函数式接口");
         return Integer.compare(x, y);
        };

2.5 若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写

Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

2.6 Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”

(Integer x, Integer y) -> Integer.compare(x, y);

Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为javac根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的"类型推断"

• 上联：左右遇一括号省
• 下联：左侧推断类型省
• 横批：能省则省

3.函数式接口

• 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。
• 你可以通过Lambda 表达式来创建该接口的对象。（若Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

3.1自定义函数式接口

如果我们想将将一串字母转化成大写，这个时候我们通过自定义函数式接口，分析:我们需用传入一个T(String)类型的元素，经过一系列操作(如将字母变为大写)，返回T(String)类型的元素

• 函数为(MyFuntion)

@FunctionalInterface
public interface MyFunction<T>{
    T apply(T t);
}

可以看到将接口上使用@FunctionalInterface注解,注意:接口中方法前面不要用public修饰

• 将字母转化成大写的方法

public String toUpperString3(String str,MyFunction<String> func) {
        return func.apply(str);
    }

这里看到将str传入了MyFunction的apply方法中了

• 使用

public void test() {
        String upStr = toUpperString3("abc", (e) -> e.toUpperCase());
        System.out.println(upStr);
    }

一般自定义函数接口就是这样使用的，这里面最重要的就是自定义的函数接口，函数接口要符合我们要操作的类型。为例避免我们每一次使用都有新建函数接口，java8中定义好了一系列的函数接口。

3.2内置四大核心函数式接口

下面四个函数式接口是我们经常使用到的，一些其他的接口都是通过继承这四大种类函数来进行扩展，这四种接口一定要记住

Consumer

• 方法:void accept(T t);
• 作用：对类型为T的对象应用操作

使用

//1.消费型
    public void happy(String name, Consumer<String> con) {
        con.accept(name);
    }
    @Test
    public void test1() {
        happy("李四",(x)-> System.out.println(x+"大保健"));
    }

Supplier

• 方法：T get();
• 作用：返回类型为T的对象
  使用

//2.供给型
    public List<Integer> getNum(Integer size, Supplier<Integer> supplier) {
        List<Integer> nums = new ArrayList<>();
        for (int i=0;i<size;i++) {
            Integer integer = supplier.get();
            nums.add(integer);
        }
        return nums;
    }
    @Test
    public void test2() {
        List<Integer> nums = getNum(6, () -> (int) (Math.random() * 100));
        for (Integer i : nums) {
            System.out.println(i+"");
        }
    }

Function

• 方法：R apply(T t);
• 作用：对类型为T的对象应用操作，并返回结果。结果是R类型的对象。

使用

public String subStr(String str, Function<String, String> function) {
        return function.apply(str);
    }
    @Test
    public void test3() {
        String str = subStr("hellokotlin", (x) -> x.substring(5));
        System.out.println(str);
    }

Predicate

• 方法：boolean test(T t);
• 作用：确定类型为T的对象是否满足某约束，并返回boolean 值。

使用

public boolean isContinKotlin(String str, Predicate<String> pre) {
        return pre.test(str);
    }
    @Test
public void test5() {
        System.out.println(isContinKotlin("stKotlin",(str)->str.contains("Kotlin")));
    }

其他重要函数

函数接口	参数类型	返回类型	用途
BiFunction < T,U,R>	T,U	R	对类型为T,U参数应用操作，返回R类型的结果。包含方法为Rapply(Tt,Uu);
UnaryOperator< T>(Function子接口)	T	T	对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为Tapply(Tt);
BinaryOperator< T>(BiFunction子接口)	T,T	T	对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为Tapply(Tt1,Tt2);
BiConsumer< T,U>	T,U	T	对类型为T,U参数应用操作。包含方法为voidaccept(Tt,Uu)

4.方法引用和构造器引用

4.1方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符“::” 将方法名和对象或类的名字分隔开来。

如下三种主要使用情况：

• 对象 :: 实例方法
• 类 :: 静态方法
• 类 :: 实例方法

1.对象 ::** 实例方法**

Consumer<String> con = (str) -> ps.println(str);
//等同于:
Consumer<String> con3 = System.out::println;

System.out是一个对象

2.类 ::** 静态方法 **

BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
//等同于
BiFunction<Double, Double, Double> fun2 = Math::max;

3.类 ::** 实例方法**

BiPredicate<String, String> bp = (x, y) -> x.equals(y);
//等同于
BiPredicate<String, String> bp2 = String::equals;

注意：
①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时(第三种)，格式： ClassName::MethodName

4.2构造器引用

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！

//无参构造函数
Supplier<Employee> sup = () -> new Employee();
//等同于,调用的是无参构造函数
Function<String, Employee> fun = Employee::new;

//有参构造函数
Function<String,Employee> fun1=(e)->new Employee(e);
//等同于,调用的是有参构造函数
Function<String, Employee> fun = Employee::new;

4.3数组引用

//传入一个Integer返回一个Integer长度的数组
Function<Integer, String[]> fun = (args) -> new String[args];
//等同于
Function<Integer,String[]> fun3=String[]::new;