JDK8新特性

只为自己记忆方便

一、接口新增内容

1.接口中默认方法
 2.接口中静态方法

eg:

public interface UserService {
    void save(User user);

    User find(int id);

    default int getNumber() {
        return 1;
    }
    
    public static void show(){
        System.out.println("new static method");
    }
}

二、Lambda表达式

     1.完整的Lambda表达式由三部分组成：参数列表、箭头、声明语句；

      2.当lambda表达式的参数个数只有一个，可以省略小括号

      3.当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号

三、函数接口是只有一个抽象方法的接口， 用作 Lambda 表达式的返回类型。

eg:

public interface UserService {
    void save(User user);
}

public class UserController {
    public void save(UserService userService,User user){
        userService.save(user);
    }
}

User user=new User(1,"name");
UserController userController=new UserController();

//lambda表达方式，类似匿名内部类
userController.save((u) ->{
    System.out.println(u);
},user);

四、常用接口（可用lambda方便表达）

1.Supplier<User> supplier  仅包含无惨方法（T get();），用来获取指定类型对象
public static User getUser(Supplier<User> supplier){
    return supplier.get();
}

@Test
public void testGetUser( ){

    User user=getUser(()->{
       return new User(1,"name");
    });     getUser(()->{
    return new User();
  });

     // 上面代码的另外一种写法 ,方法引用 ，通过双冒号的方式

       getUser(User::new);

    System.out.println(user);
}

2.Consumer 消费一个对象

/**
 * Performs this operation on the given argument.
 *对给定的参数T执行定义的操作
 * @param t the input argument
 */
void accept(T t);
//对给定的参数T执行定义的操作执行再继续执行after定义的操作
default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}

eg.

public class ConsumerTest {

    @Test
    public void consumerTest(){
        User u=new User(1,"zhangsan");
        consumerUser(user -> {
            System.out.print(user);
        },u);
        System.out.println("-------------------------------");
        consumerUser(user ->{
            user.setId(12);
            System.out.println(user);
        },user->{
            user.setName("lisi");
            System.out.println(user);
        },u );
    }

    public void consumerUser(Consumer<User> consumer,User user){
        consumer.accept(user);
    }

    public void consumerUser(Consumer<User>consumer,Consumer<User> userConsumer,User user){
        consumer.andThen(userConsumer).accept(user);
    }
}

执行结果如下，连续改变对象的值

3.Predicate 判断函数

核心方法，通过方法能够判断出对应的使用方式。

boolean test(T t); 判断
default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); }

default Predicate<T> negate() { return (t) -> !test(t); }

default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); }

static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); }

4.Function<T,R>  T为对象的应用操作，R为返回值对象 核心方法R apply(T t)

@Test
public void functionTest(){

   int result= functionUser(s -> {
        return Integer.parseInt(s);
    },"1234");//静态方法方法引用   类名::方法名 
int result2=functionUser(Integer::parseInt,"1235");

   System.out.println(result);
}

public int functionUser(Function<String,Integer> function,String str){
   int result= function.apply(str);
   return result;

}

图片地址来源：https://blog.csdn.net/weixin_34266504/article/details/92736948