1. 基础

1.1. Consumer 函数式接口

public void demo(Consumer<String> consumer){
        consumer.accept("ab");
    }
demo(res->{
            System.out.println(res);
        });

1.2. Function 接口

1.2.1. 函数式接口

 @FunctionalInterface
    interface GreetingService
    {
        void sayMessage(String message);
        // 默认方法，可以用多个默认方法
        public default void setUser() {
            System.out.println("user");
        }

        // 静态方法
        public static void saveUser() {
        }

        // 覆盖Object中的equals方法
        public boolean equals(Object obj);
    }
    new GreetingService() {
            @Override
            public void sayMessage(String message) {
                System.out.println(message);
            }
        }.setUser();

相关信息

函数式接口只能包含一个抽像类，可以存在多个默认方法

1.2.2. Predicate 条件过滤：and or

public static void main(String[] args) {
        new demo1().test("456",r->{
            return r.equals("123");
        }, r-> {return r.equals("456");});
    }
    public void test(String value,Predicate<String> pred1, Predicate<String> pred2){
        System.out.println(pred1.or(pred2).and(pred2).test(value));
    }

注

and: 与操作、 or: 或操作、 test: 匹配传入的值，返回布尔型、 negate: 取反操作

1.3. 对象自动释放

//以写入文件为例
try(FileWriter fw = new FileWriter("test.txt")) {
    fw.write("test");
} catch(Exception ex) {
    ex.printStackTrace();
}

1.3.1. 抽象类

1.3.1.1. 定义一个类继承抽象为自身

public abstract class Base<T>{
        public T test() {

            return (T)this;//返回本身
        }
    }
    public class demo extends Base<demo> {
        public demo demo1(){
            return this;
        }
    }
//调用父类方法可返回类本身进行方法链使用
new demo().test().demo1();

1.4. map 操作

1.4.1. map 实现 if 操作

    public void dispatcherInit(){
        grantTypeMap.put("红包",resourceId->grantTypeSerive.redPaper(resourceId));
        grantTypeMap.put("购物券",resourceId->grantTypeSerive.shopping(resourceId));
        grantTypeMap.put("qq会员",resourceId->grantTypeSerive.QQVip(resourceId));
    }

    public String getResult(String resourceType){
        //Controller根据 优惠券类型resourceType、编码resourceId 去查询 发放方式grantType
        Function<String,String> result=getGrantTypeMap.get(resourceType);
        if(result!=null){
         //传入resourceId 执行这段表达式获得String型的grantType
            return result.apply(resourceId);
        }
        return "查询不到该优惠券的发放方式";
    }
    public class GrantTypeSerive {

        public String redPaper(String resourceId){
            //红包的发放方式
            return "每周末9点发放";
        }
        public String shopping(String resourceId){
            //购物券的发放方式
            return "每周三9点发放";
        }
        public String QQVip(String resourceId){
            //qq会员的发放方式
            return "每周一0点开始秒杀";
        }
    }

1.5. 排序

List<Map<String,Integer>> list=new ArrayList<>();
        for (int i = 3; i > 0; i--) {
            Map<String, Integer> empty = MapUtil.of("id",4);
            empty.put("id",i);
            empty.put("name",i*2);
            list.add(empty);
        }
        System.out.println(list);
        System.out.println(CollUtil.sort(list, (s1, s2) -> s1.get("id").compareTo(s2.get("id"))));

2. 控制器

2.1. 异步

@GetMapping("/addBillData")
    @ResponseBody
    public WebAsyncTask<AjaxResult> addBillData(){
        Callable<AjaxResult> callable = new Callable<AjaxResult>() {

            @Override
            public AjaxResult call() throws Exception {
                Thread.sleep(5*1000);
                AjaxResult result=new AjaxResult();
                result.put("code","0000");
                System.out.println(result);
                return result;
            }
        };
//        AjaxResult result=new AjaxResult();
//        result.put("code","0000");
        return new WebAsyncTask<AjaxResult>(callable);
    }
async异步只能在开启新的线程执行，前端不会执行后再返回
如果使用其他的异步方式，需要执行异步执行完，再进行返回

3. 回调函数

3.1. 基础应用

t(new hd() {
            @Override
            public void run() {
                System.out.println("run");
            }
        });
public void t(hd par){
        System.out.println("t");
        par.run();
    }
    @FunctionalInterface
    public interface hd{
        public abstract void run();
    }

4. 设计模式

4.1. 观察者模式

相关信息

观察者模式（Observer Pattern）是一种行为型设计模式，也叫发布 - 订阅模式，它定义了对象之间一对多的依赖关系，使得当一个对象状态改变时，所有依赖它的对象都能收到通知并自动更新。

观察者模式中，有两种类型的对象：观察者和主题（或称为被观察者）。观察者将自己注册到主题，以便在主题的状态改变时接收通知。主题会维护一组观察者，并在自身状态改变时通知它们。主题通过调用观察者的统一接口来通知它们状态的变化。

以下是简单的观察者模式示例代码：

// 观察者接口
interface Observer {
    void update(String message);
}

// 具体观察者1
class ConcreteObserver1 implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserver1：" + message);
    }
}

// 具体观察者2
class ConcreteObserver2 implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserver2：" + message);
    }
}

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObserver(String message);
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> list = new ArrayList<>();

    // 注册观察者
    public void registerObserver(Observer observer) {
        list.add(observer);
    }

    // 移除观察者
    public void removeObserver(Observer observer) {
        list.remove(observer);
    }

    // 通知观察者
    public void notifyObserver(String message) {
        for (Observer observer : list) {
            observer.update(message);
        }
    }
}

在上面的代码中，我们有观察者接口 Observer 和具体实现的两个观察者 ConcreteObserver1 和 ConcreteObserver2。还有主题接口 Subject，它有三个方法：registerObserver、removeObserver 和 notifyObserver，用于注册观察者、移除观察者和通知观察者。最后，我们有一个具体的主题 ConcreteSubject，它维护了 Observer 对象的列表，实现了 Subject 接口中的三个方法。 以下是使用 Java 观察者模式的示例代码：

public class ObserverTest {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject(); // 创建具体主题
        Observer observer1 = new ConcreteObserver1(); // 创建具体观察者1
        Observer observer2 = new ConcreteObserver2(); // 创建具体观察者2
        subject.registerObserver(observer1); // 注册观察者1
        subject.registerObserver(observer2); // 注册观察者2
        subject.notifyObserver("观察者模式测试"); // 通知所有观察者
    }
}