虽然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);
}
}