JDK8新特性详解（一）

2023-12-12 15:18:40

虽然JDK8已经出来了N久，其新特性也在日益改变着我们的编码习惯和风格。虽然有些新特性用起来很顺手，但是总是傻傻分不清到底是哪个版本的。趁今天有时间，我们就来总结一下，JDK8有哪些能提升我们开发效率的新特性：

一、静态方法的默认方法和静态方法

众所周知，在接口中定义的普通方法都是抽象方法，方法前面默认都会添加 public abstract ，不能有方法实现，需要在接口的实现类中对方法进行具体实现。

接口：

package com.beck.util;

/**
 * @author 我是七月呀
 * @date 2020/12/18
 */
public interface MethodService {
    /**
     * 抽象方法
     */
    void abstractMethod();

    /**
     * 默认方法
     */
    default void defaultMethod(){
        System.out.println("执行了默认方法");
    }

    /**
     * 静态方法
     */
    static void staticMethod(){
        System.out.println("执行了静态方法");
    }

}

实现类：

package com.beck.util;

/**
 * @author 我是七月呀
 * @date 2020/12/18
 */
public class MethodServiceImpl implements MethodService {

    @Override
    public void abstractMethod() {
        System.out.println("执行了抽象方法");
    }

}

测试类：

package com.beck.util;

/**
 * @author 我是七月呀
 * @date 2020/12/18
 */
public class TestMethod {

    public static void main(String[] args) {
        MethodServiceImpl methodService = new MethodServiceImpl();
        methodService.abstractMethod();
        methodService.defaultMethod();
        //调用静态方法
        MethodService.staticMethod();
        MethodService methodServiceOne = new MethodService() {
            @Override
            public void abstractMethod() {
            }

            @Override
            public void defaultMethod() {
                System.out.println("默认方法是可以被重写的");
            }
        };
        methodServiceOne.defaultMethod();
    }
}

 public class Student { 
    private int id;      
     private String name;     
     private String sex;     
     public int getId() {         return id;     }       public void setId(int id) {         this.id = id;     }       public String getName() {         return name;     }       public void setName(String name) {         this.name = name;     }       public String getSex() {         return sex;     }       public void setSex(String sex) {         this.sex = sex;     }       public Student() {     }       public Student(int id, String name, String sex) {         this.id = id;         this.name = name;         this.sex = sex;     }       @Override     public String toString() {         return "Student{" +             "id=" + id +             ", name='" + name + '\'' +             ", sex='" + sex + '\'' +             '}';     } }

总结：1、抽象方法必须重写，默认方法可选择性重写，静态方法无法重写

2、抽象方法和默认方法都不可以通过接口调用，必须通过接口的实现类实例的对象来调用；静态方法可以直接通过接口调用，不可以通过接口的实现类实例的对象来调用

二、Lambda表达式

Lambda表达式是Java8中非常重要的一个新特性，其基于函数式编程的思想，支持将代码作为方法参数进行使用。可以把Lambda表达式理解为通过一种更加简洁的方式表示可传递的匿名函数。
它本身没有名称，而且不像方法那样属于某一个类，但是可以有参数列表、代码体、返回值。使用了Lambda表达式之后就不需要再去编写匿名类了

Lambda使用规范

Lambda基础格式

(参数列表) ‐> { 
    方法体      
}

参数列表：即匿名方法的形参
-> ：Lambda运算符
方法体：用于执行业务逻辑。可以是单一语句，也可以是语句块。如果是单一语句，可以省略花括号。当需要返回值，如果方法体中只有一条语句，可以省略return，会自动根据结果进行返回。

1、数的Lambda表达式；
()->System.out.println("haha");
2、只有一个参数的Lambda表达式；
x->{
    System.out.println("haha");
    return x;
}
3、有多个参数的Lambda表达式；
(x,y)->{
    System.out.println(x);
    System.out.println(y);
    return x+y;
}
ps:参数列表中参数的数据类型可以交给JVM根据上下文进行推断。所以可以 不用定义类型。
4、多个参数一条语句的Lambda表达式
(x,y) -> x+y;

Lambda使用对比

package com.beck.util.student;
import java.util.ArrayList;
/**
 * @author 我是七月呀
 * @date 2020/12/18
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");
        //for循环遍历
        for (String s : list) {
            System.out.println(s);
        }
        //lambda表达式遍历
        list.forEach(s -> System.out.println(s));

        //匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("I'm running");
            }
        };
        //lambda表达式
        Runnable runnable1 = () -> System.out.println("I'm running");
    }
}

三、函数式接口

在Java8中为了让现在有的函数能够更加友好的使用Lambda表达式，因此引入了函数式接口这个概念。其是一个仅有一个抽象方法的普通接口。如果声明多个抽象方法则会报错。但是默认方法和静态方法在此接口中可以定义多个。要想自定义一个函数式接口的话，需要在接口上添加 @FunctionalInterface 。

/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
@FunctionalInterface
public interface DemoService {

    void method();
}

/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
public class Demo {
    public static void demo(DemoService demoService){
        demoService.method();
    }

    public static void main(String[] args) {
        demo(()-> System.out.println("hahahah"));
    }

}

四、常见应用

在Java8的类库设计中，已经引入了几个函数式接口：Predicate、Consumer、Function、Supplier

1、Predicate使用

Predicate接口是Java8定义的一个函数式接口，属于java.util.function包下，用于进行判断操作，内部定义一个抽象方法test、三个默认方法and，negate，or、一个静态方法isEqual

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
public class MyPredicateDemo {
    public static List<Student> filter(List<Student> studentList, Predicate<Student> predicate) {
        ArrayList<Student> list = new ArrayList<>();
        studentList.forEach(student ->  {
        if (predicate.test(student)) {
            list.add(student);
        }
    });
        return list;
    }

    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student(1, "张三", "M"));
        students.add(new Student(2, "李四", "M"));
        students.add(new Student(3, "王五", "F"));
        List<Student> result = filter(students, student -> student.getSex().equals("F"));
        System.out.println(result.toString());
    }
}

2、Consumer使用

Consumer也是JDK8提供的函数式接口，用于进行获取数据的操作，其内部定义了一个抽象方法accept、一个默认方法andThen。

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
public class MyConsumerDemo {
public static void foreach(List<String> arrays, Consumer<String> consumer){
    arrays.forEach(s -> consumer.accept(s));
    }
    public static void main(String[] args) {
    List<String> arrays = new ArrayList<>();
    arrays.add("java");
    arrays.add("python");
    arrays.add("go");
    arrays.add("hive");
    foreach(arrays,s -> System.out.print(s+" "));
    }
}

3、Function的使用

Function主要用于进行类型转换的操作。内部提供一个抽象方法apply、两个默认方法compose，andThen、一个静态方法identity。对于apply方法，它接收一个泛型T对象，并返回一个泛型R的对象。

import java.util.function.Function;
/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
public class MyFunctionDemo {
public static Integer convert(String value, Function<String,Integer> function){
    return function.apply(value);
}
public static void main(String[] args) {
    String value = "22";
    Integer result = convert(value, s -> Integer.parseInt(s) + 22);
    System.out.println(result);
    }
}

4、Supplier 的使用

Supplier也是用来进行值获取操作，内部只有一个抽象方法get

import java.util.function.Supplier;
/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
public class MySupplierDemo {
    public static Integer getMin(Supplier<Integer> supplier){

        return supplier.get();
    }
    public static void main(String[] args) {
    // 创建数组
    int[] arr = {100,20,50};
        Integer result = getMin(() -> {
            int min = arr[0];
            for (int i : arr) {
                if (i < min) {
                    min = i;
                }
            }
            return min;
        });

        System.out.println(result);
    }
}

五、方法引用

方法引用更近一步的优化了Lambda的使用。它让代码感觉更加的自然。我们可以直接使用 :: 来简化Lambda表达式的使用。其使用语法如下：

类名或实例名::方法名

import java.util.ArrayList;
import java.util.Comparator;

/**
 * @author 我是七月呀
 * @date 2020/12/21
 */
public class MyDemo {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        Student student1 = new Student(2,"张三","M");
        Student student2 = new Student(1,"李四","F");
        students.add(student1);
        students.add(student2);
        students.sort(Comparator.comparing(Student::getId));
        System.out.println(students);
    }
}

码农公寓

相关文章