JDK1.8新特性:
1.接口中可以定义:
(1)带方法体的默认方法default修饰:调用方式通过实例化子类去调用。
(2)带方法体的静态方法:调用方法直接类名调用。
接口中只有不带方法体的抽象方法和带方法体的默认方法,可以被重写,而静态方法不可以被重写。
lambda表达式是java1.8中的重要特性,其基于函数式编程的思想,支持将代码作为方法参数进行使用,可以把lamda表达式理解为通过一种更简洁的方式表示可传递的匿名函数。
2.Lambda使用规范:
(1)基础格式:(参数列表)->{方法体}
方法体用来执行业务逻辑,可以是单一语句,也可以是语句块,如果是单一语句花括号可以省略,当需要返回值,如果方法体中只有一条语句,可以省略return,会自动根据结果进行返回。
(2)没有参数的lambda表达式:()->new Student
(3)只有一个参数的lambda表达式(会根据上下文判断数据类型)
x->{ system.out.prient(x); return x;}
(4)多个参数的lambda表达式(会根据上下文判断数据类型):
(int x,inty)->{system.out.println(x);system.out.println(y) ;return x+y}
(5)一条语句一个参数lambda表达式:
x->3+x
(6)多个参数一条语句lambda表达式:
(x,y)->x+y
(7)Lambda替换匿名内部类:
//替换前
Runnable runnable= new Runnable(){
@Override
public void run{
System.out.println("a");
}
};
//替换后
Runnable runnable = ()-> System.out.println()("a");
//替换前
Arrays.sort(array,new Comparator<String>(){
@Override
public int compare(String o1,String o2){
return o1.compareTo(o2);
}
});
//替换后
Arrays.sort(array,(o1,o2)-> o1.compareTo(o2));
3.函数式接口:
函数式接口:仅有一个抽象方法的普通接口,如果声明多个抽象接口会报错,但是默认的方法和静态方法再此接口中可以定义多个。
定义:定义一个函数式接口需要在类上加@FunctionalInterface。
例子:
@FunctionalInterface
public interface MyFunctionalInterface {
void exec();//只允许有一个抽象方法
}
public class Demo1 {
public void invork(MyFunctionalInterface myFunctionalInterface){
myFunctionalInterface.exec();
}
@Test
public void test1(){
invork(new MyFunctionalInterface() {
@Override
public void exec() {
System.out.println("匿名内部类");
}
});
}
@Test
public void test2(){
invork(()-> System.out.println("测试函数式接口"));
}
}
Lambda表达式中的方法体就是函数式接口的抽象方法的实现
5.常见的函数式接口Predicate、Consumer、Function、Supplier
(1)Predicate:java.util.function包下作用用来进行数据判断,抽象方法【boolean test(T t)】
例子:
public class MyPredicate {
public static List<UserEntity> filter(List<UserEntity> users, Predicate<UserEntity> predicate){
List<UserEntity> list= new ArrayList<>();
users.forEach(user->{
if(predicate.test(user))
{
list.add(user);
}
});
return list;
}
public static void main(String[] args) {
UserEntity userEntity0 = new UserEntity("张三",23);
UserEntity userEntity1 = new UserEntity("王五",24);
UserEntity userEntity2 = new UserEntity("李四",13);
List<UserEntity> list=new ArrayList<>();
list.add(userEntity0);
list.add(userEntity1);
list.add(userEntity2);
List<UserEntity> filter = filter(list, (user) -> user.getAge() > 13);
System.out.println(JSON.toJSONString(filter));
}
}
(2)Consumer:java.util.function包下作用用来进行数据的获取,抽象方法【void accept(T t)】
例子:
public class MyConsumer {
public static void foreach(List<String> list, Consumer<String> consumer){
list.forEach(a->consumer.accept(a));
}
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
foreach(list,(x)-> System.out.println(x));
}
}
(3)Function:java.util.function包下作用用来进行类型的转换,抽象方法【R apply(T t)】
例子:
public class MyFunction {
public static Double convert(BigDecimal bigDecimal, Function<BigDecimal,Double> function){
return function.apply(bigDecimal);
}
public static void main(String[] args) {
BigDecimal bigDecimal=new BigDecimal("1.21");
Double convert = convert(bigDecimal,(a) -> Double.valueOf(a.toString())+12);
System.out.println(convert);
}
}
(4)Supplier:java.util.function包下作用用来获取值操作有返回值,抽象方法【T get()】
例子:
public class MySupplier {
public static Integer getMin(Supplier<Integer> supplier){
return supplier.get();
}
public static void main(String[] args) {
int array[]={11,121,-12,33,0,43};
Integer minNum = getMin(() -> {
int min = array[0];
for (int num : array)
{
if (num < min)
{
min = num;
}
}
return min;
});
System.out.println(minNum);
}
}