Java8学习随笔

Java8

接口默认方法

package com.albert.sjms.jdk8;

/**
 * jdk8接口默认方法
 */
public interface Jdk8Interface {
    //默认就是public abstract
    void add();
    //默认的方法
    default String get(){
        return null;
    }
    static void staticDel(){

    }
}

package com.albert.sjms.jdk8;

public class Jdk8InterfaceImpl implements Jdk8Interface {
    //只强制要求重写抽象方法，默认和静态不要求重写
    @Override
    public void add() {

    }
}

lambda

• 什么是lambda

  简化匿名内部类调用，是一个匿名函数,

  package com.albert.sjms.jdk8.service;
  
  public interface OrderService {
  
      void get();
      /**
       * 如果需要使用到OrderService接口
       * 接口是无法new的，可以通过匿名内部类new
       * 定义子类
       */
  }
  

  package com.albert.sjms.jdk8;
  
  import com.albert.sjms.jdk8.service.OrderService;
  
  public class LambdaTest {
      public static void main(String[] args) {
        //匿名内部类方式
          OrderService orderService = new OrderService() {
              @Override
              public void get() {
                  System.out.println("匿名内部类方式");
              }
          };
          orderService.get();
        //Lambda
        ((OrderService) () -> System.out.println("Lambda方式")).get();
      }
    
  }
  

  依赖于函数接口

  1、接口中只能允许有一个抽象方法,默认和静态方法不限制

  2、在函数接口中定义object类中方法

  3、使用默认或静态方法

  4、@FunctionalInterface 标识该接口是函数式接口,加了该注解接口里就不能添加抽象方法了

  package com.albert.sjms.jdk8.service;
  
  @FunctionalInterface
  public interface MyFunctionInterface {
      void get();
  
      default void add(){
  
      }
  
      /**
       * Object父类的方法是可以在函数接口中重写
       * @return
       */
      @Override
      String toString();
      
  }
  
  

• 基础语法

  （a,b…）：参数列表 //名称不允许重复

  -> ：分割符

  {} ：方法体

  () -> {}

public class LambdaTest {
    public static void main(String[] args) {
        //无参的
        MyFunctionInterface myFunctionInterface = () -> {
            System.out.println("Lambda");
        };
        myFunctionInterface.get();
        //有参的（将MyFunctionInterface的get方法变成  String get(int a,int b); ）
        MyFunctionInterface myFunctionInterface = (a,b) -> a+"======"+b;
        String s = myFunctionInterface.get(1,1);
        //有参的简洁写法
        String s = ((MyFunctionInterface) (a,b) -> a+"======"+b).get(1,1);
    }
  
}

注：

​ 1.参数类型可以省略

​ 2.一个参数的话，（）可以省略

​ 3.方法体只有一条语句，{}可以省略

​ 4.方法体唯一语句也是return的话，省略{}同时也可省略return

方法引用：

多个lambda表达式实现函数是一样的话，我们可以封装成通用方法，以便于维护，语法：

​ 对象::方法

​ 类::方法

package com.example.mybatisplus.utils;

public class Java8Test {
    interface if1{
        int test(int a);
    }
    //非静态的方法实现
    public int test1(int a){
        return a-2;
    }
    public static void main(String[] args) {
        Java8Test java8Test = new Java8Test();
        if1 if1 = java8Test::test1;
        if1.test(3);
    }
}

构造方法引用：

如果函数接口的实现恰好可以调用一个类的构造方法实现，语法：

​ 类名::new

内置的函数式接口

java.util.function

Stream

1、创建流 (串行流【相当于单线程】、并行流【相当于多线程】)

2、中间操作（过滤、去重、排序、分页…）

3、终止操作（forEach.collect.min.max.allMatch）

Optional容器

创建

Optional.of(T t);  //创建一个Optional实例，t必须非空
Optional.empty();  //创建一个空的Optional实例
Optional.ofNullable(T t); //t可以为null

判断容器中是否包含对象

boolean isPresent();   判断是否包含对象
void ifPresent(Consumer<? super T>);//如果有值就会执行Consumer接口实现的代码，并且该值作为参数传进去  

获取容器对象

T get();  //返回该对象值，如果对象空抛异常
T orElse(T other); //有值将其返回，没有值返回other
T orElseGet(supplier<? extends T> other); //有值将其返回，否则返回由supplier接口实现提供的对象
T orElseThrow(supplier<? extends X> exceptionsupplier); //有值返回，否则抛出由supplier接口实现的异常

Filter 过滤值

Map 转换值

public class OptionalMapFilterDemo {
    public static void main(String[] args) {
        String password = "password";
        Optional<String>  opt = Optional.ofNullable(password);

        Predicate<String> len6 = pwd -> pwd.length() > 6;
        Predicate<String> len10 = pwd -> pwd.length() < 10;
        Predicate<String> eq = pwd -> pwd.equals("password");

        boolean result = opt.map(String::toLowerCase).filter(len6.and(len10 ).and(eq)).isPresent();
        System.out.println(result);
    }
}

例一

在函数方法中，以前写法。

public String getCity(User user)  throws Exception{
        if(user!=null){
            if(user.getAddress()!=null){
                Address address = user.getAddress();
                if(address.getCity()!=null){
                    return address.getCity();
                }
            }
        }
        throw new Excpetion("取值错误"); 
    }

JAVA8写法。

public String getCity(User user) throws Exception{
    return Optional.ofNullable(user)
                   .map(u-> u.getAddress())
                   .map(a->a.getCity())
                   .orElseThrow(()->new Exception("取指错误"));
}

例二

比如，在主程序中，以前写法。

if(user!=null){
    dosomething(user);
}

JAVA8写法。

 Optional.ofNullable(user)
    .ifPresent(u->{
        dosomething(u);
});

例三

以前写法。

public User getUser(User user) throws Exception{
    if(user!=null){
        String name = user.getName();
        if("zhangsan".equals(name)){
            return user;
        }
    }else{
        user = new User();
        user.setName("zhangsan");
        return user;
    }
}

java8写法。

public User getUser(User user) {
    return Optional.ofNullable(user)
                   .filter(u->"zhangsan".equals(u.getName()))
                   .orElseGet(()-> {
                        User user1 = new User();
                        user1.setName("zhangsan");
                        return user1;
                   });
}