基于Java的函数式实现的构建者

已于 2023-02-07 17:01:41 修改
阅读量182 收藏
点赞数
分类专栏： java8 设计模式 文章标签： java 前端 数据库
于 2023-02-06 15:06:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39956506/article/details/128902069
版权
该文介绍了使用Java的函数式接口如Supplier、Consumer、Function、BiConsumer和BiFunction来实现构建者模式，提供了不同类型的构建者类，支持在构建过程中添加操作并执行。这些构建者类允许在对象创建后按顺序应用一系列操作，增强了代码的灵活性和可读性。
摘要由CSDN通过智能技术生成

基于Java的函数式实现的构建者

一、基于Java的Supplier实现的构建者

package com.function.bulider;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class SupplierBulider<T> {

    /**
     * 待创建的类型
     */
    private final Supplier<T> supplier;

    /**
     *  存储需要执行的过程
     */
    private final List<Consumer<T>> list = new ArrayList<>();

    public SupplierBulider(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    public static <T> SupplierBulider<T> of(Supplier<T> supplier) {
        return new SupplierBulider<>(supplier);
    }


    /**
     * 把 Value 赋值给 supplier
     *
     * @param biConsumer
     * @param value
     * @param <V>
     * @return
     */
    public <V> SupplierBulider<T> width(BiConsumer<T, V> biConsumer, V value) {
        list.add(t -> biConsumer.accept(t, value));
        return this;
    }

    public <V> SupplierBulider<T> width(BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (null == value) {
            list.add(t -> biConsumer.accept(t, value));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    public <V> SupplierBulider<T> width(boolean accept, BiConsumer<T, V> biConsumer, V value) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, value));
        }
        return this;
    }

    public <V> SupplierBulider<T> width(boolean accept, BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, value));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    /**
     * 开始构建
     *
     * @return
     */
    public T build() {
        T t = supplier.get();
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(t));
        return t;
    }


    /**
     * 开始构建
     *
     * @return
     */
    public T build(List<Consumer<T>> list) {
        T t = supplier.get();
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(t));
        return t;
    }
}

二、基于Java的Consumer实现的构建者

package com.function.bulider;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class ConsumerBulider<T> {
    /**
     * 消费数据
     */
    private final T consumer;

    /**
     * 存储需要执行的过程
     */
    private final List<Consumer<T>> list = new ArrayList<>();

    public ConsumerBulider(T consumer) {
        this.consumer = consumer;
    }

    public static <T> ConsumerBulider<T> of(T consumer) {
        return new ConsumerBulider<>(consumer);
    }


    public <V> ConsumerBulider<T> width(BiConsumer<T, V> biConsumer, V value) {
        list.add(e -> biConsumer.accept(e, value));
        return this;
    }

    public <V> ConsumerBulider<T> width(BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (null == value) {
            list.add(e -> biConsumer.accept(e, value));
        } else {
            list.add(e -> biConsumer.accept(e, orElse));
        }
        return this;
    }

    public <V> ConsumerBulider<T> width(boolean accept, BiConsumer<T, V> biConsumer, V value) {
        if (accept) {
            list.add(e -> biConsumer.accept(e, value));
        }
        return this;
    }

    public <V> ConsumerBulider<T> width(boolean accept, BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (accept) {
            list.add(e -> biConsumer.accept(e, value));
        } else {
            list.add(e -> biConsumer.accept(e, orElse));
        }
        return this;
    }

    public T build() {
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(e -> e.accept(consumer));
        return consumer;
    }

    /**
     * 开始构建
     *
     * @return
     */
    public T build(List<Consumer<T>> list) {
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(e -> e.accept(consumer));
        return consumer;
    }


}

三、基于Java的Function实现的构建者

package com.function.bulider;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class FunctionBulider<T, S> {
    /**
     * 消费数据
     */
    private final S s;
    /**
     * 待创建的类型
     */
    private final Supplier<T> supplier;

    private final List<Consumer<T>> list = new ArrayList<>();

    public FunctionBulider(S s, Supplier<T> supplier) {
        this.s = s;
        this.supplier = supplier;
    }

    /**
     * 静态工厂方法，获取类型转换
     *
     * @param s        数据源
     * @param supplier 目标值
     * @param <T>      目标类型
     * @param <S>      数据源类型
     * @return 构造函数
     */
    public static <T, S> FunctionBulider<T, S> of(S s, Supplier<T> supplier) {
        return new FunctionBulider<>(s, supplier);
    }

    /*** ++++++++++ 引用赋值 ++++++++++ ***/

    public <V> FunctionBulider<T, S> width(BiConsumer<T, V> biConsumer, V value) {
        list.add(t -> biConsumer.accept(t, value));
        return this;
    }

    public <V> FunctionBulider<T, S> width(BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (null == value) {
            list.add(t -> biConsumer.accept(t, value));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    public <V> FunctionBulider<T, S> width(boolean accept, BiConsumer<T, V> biConsumer, V value) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, value));
        }
        return this;
    }

    public <V> FunctionBulider<T, S> width(boolean accept, BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, value));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    /*** ++++++++++ 映射赋值 ++++++++++ ***/

    public <V> FunctionBulider<T, S> mapper(BiConsumer<T, V> biConsumer, Function<S, V> function) {
        list.add(t -> biConsumer.accept(t, function.apply(s)));
        return this;
    }

    public <V> FunctionBulider<T, S> mapper(BiConsumer<T, V> biConsumer, Function<S, V> function, V orElse) {
        if (function == null) {
            list.add(t -> biConsumer.accept(t, orElse));
        } else {
            list.add(t -> biConsumer.accept(t, function.apply(s)));
        }
        return this;
    }


    public <V> FunctionBulider<T, S> mapper(boolean accept, BiConsumer<T, V> biConsumer, Function<S, V> function) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, function.apply(s)));
        }
        return this;
    }

    public <V> FunctionBulider<T, S> mapper(boolean accept, BiConsumer<T, V> biConsumer, Function<S, V> function, V orElse) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, function.apply(s)));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    /**
     * 开始构建
     *
     * @return
     */
    public T build() {
        T t = supplier.get();
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(t));
        return t;
    }


    /**
     * 开始构建
     *
     * @return
     */
    public T build(List<Consumer<T>> list) {
        T t = supplier.get();
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(t));
        return t;
    }
}

四、基于Java的BiConsumer实现的构建者

package com.function.bulider;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;

public class BiConsumerBulider<T, S> {
    /**
     * 消费数据2
     */
    private final T t;
    /**
     * 消费数据2
     */
    private final S s;

    /**
     *  存储需要执行的过程
     */
    private final List<Consumer<T>> list = new ArrayList<>();

    public BiConsumerBulider(T t, S s) {
        this.t = t;
        this.s = s;
    }

    /**
     * 静态工厂方法，获取类型转换
     *
     * @param t   目标源
     * @param s   数据源
     * @param <T> 目标类型
     * @param <S> 数据类型
     * @return 构造函数
     */
    public static <T, S> BiConsumerBulider<T, S> of(T t, S s) {
        return new BiConsumerBulider<>(t, s);
    }

    /*** ++++++++++ 引用赋值 ++++++++++ ***/

    public <V> BiConsumerBulider<T, S> width(BiConsumer<T, V> biConsumer, V value) {
        list.add(t -> biConsumer.accept(t, value));
        return this;
    }


    public <V> BiConsumerBulider<T, S> width(boolean accept, BiConsumer<T, V> biConsumer, V value) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, value));
        }
        return this;
    }


    public <V> BiConsumerBulider<T, S> width(BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (null == value) {
            list.add(e -> biConsumer.accept(e, orElse));
        } else {
            list.add(e -> biConsumer.accept(e, value));
        }
        return this;
    }


    public <V> BiConsumerBulider<T, S> width(boolean accept, BiConsumer<T, V> biConsumer, V value, V orElse) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, value));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    /**** ++++++++++ 映射赋值 ++++++++++  ***/

    public <V> BiConsumerBulider<T, S> mapper(BiConsumer<T, V> biConsumer, Function<S, V> function) {
        list.add(t -> biConsumer.accept(t, function.apply(s)));
        return this;
    }


    public <V> BiConsumerBulider<T, S> mapper(BiConsumer<T, V> biConsumer, Function<S, V> function, V orElse) {
        if (function == null) {
            list.add(t -> biConsumer.accept(t, orElse));
        } else {
            list.add(t -> biConsumer.accept(t, function.apply(s)));
        }
        return this;
    }

    public <V> BiConsumerBulider<T, S> mapper(boolean accept, BiConsumer<T, V> biConsumer, Function<S, V> function) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, function.apply(s)));
        }
        return this;
    }

    public <V> BiConsumerBulider<T, S> mapper(boolean accept, BiConsumer<T, V> biConsumer, Function<S, V> function, V orElse) {
        if (accept) {
            list.add(t -> biConsumer.accept(t, function.apply(s)));
        } else {
            list.add(t -> biConsumer.accept(t, orElse));
        }
        return this;
    }

    /**
     * 开始构建
     *
     * @return
     */
    public T build() {
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(t));
        return t;
    }

    /**
     * 开始构建
     *
     * @return
     */
    public T build(List<Consumer<T>> list) {
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(t));
        return t;
    }


}

四、基于Java的BiFunction实现的构建者

package com.function.bulider;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class BiFunctionBulider<T, U, R> {
    /**
     * 消费类型1
     */
    private final T t;
    /**
     * 消费类型2
     */
    private final U u;
    /**
     * 待创建的类型
     */
    private final Supplier<R> supplier;

    /**
     * 存储返回值 R 需要执行的过程
     */
    private final List<Consumer<R>> list = new ArrayList<>();

    public BiFunctionBulider(T t, U u, Supplier<R> supplier) {
        this.t = t;
        this.u = u;
        this.supplier = supplier;
    }

    /**
     * 两个数据合并成一个数据
     *
     * @param t        源数据1
     * @param u        源数据2
     * @param supplier 返回合并的数据
     * @param <T>      源数据1类型
     * @param <U>      源数据2类型
     * @param <R>      返回的数据类型
     * @return 构造函数
     */
    public static <T, U, R> BiFunctionBulider<T, U, R> of(T t, U u, Supplier<R> supplier) {
        return new BiFunctionBulider<>(t, u, supplier);
    }


    /*** ++++++++++ 引用赋值 ++++++++++ ***/

    public <V> BiFunctionBulider<T, U, R> width(BiConsumer<R, V> biConsumer, V value) {
        list.add(r -> biConsumer.accept(r, value));
        return this;
    }

    public <V> BiFunctionBulider<T, U, R> width(boolean accept, BiConsumer<R, V> biConsumer, V value) {
        if (accept) {
            list.add(r -> biConsumer.accept(r, value));
        }
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> width(BiConsumer<R, V> biConsumer, V value, V orElse) {
        if (null == value) {
            list.add(r -> biConsumer.accept(r, orElse));
        } else {
            list.add(r -> biConsumer.accept(r, value));
        }
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> width(boolean accept, BiConsumer<R, V> biConsumer, V value, V orElse) {
        if (accept) {
            list.add(r -> biConsumer.accept(r, value));
        } else {
            list.add(r -> biConsumer.accept(r, orElse));
        }
        return this;
    }

    /*** ++++++++++ 映射赋值，来源数据类型1 ++++++++++ ***/

    public <V> BiFunctionBulider<T, U, R> width(BiConsumer<R, V> biConsumer, Function<T, V> function) {
        list.add(r -> biConsumer.accept(r, function.apply(t)));
        return this;
    }

    public <V> BiFunctionBulider<T, U, R> width(boolean accept, BiConsumer<R, V> biConsumer, Function<T, V> function) {
        if (accept) {
            list.add(r -> biConsumer.accept(r, function.apply(t)));
        }
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> width(BiConsumer<R, V> biConsumer, Function<T, V> function, V orElse) {
        if (null == function) {
            list.add(r -> biConsumer.accept(r, orElse));
        } else {
            list.add(r -> biConsumer.accept(r, function.apply(t)));
        }
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> width(boolean accept, BiConsumer<R, V> biConsumer, Function<T, V> function, V orElse) {
        if (accept) {
            list.add(r -> biConsumer.accept(r, function.apply(t)));
        } else {
            list.add(r -> biConsumer.accept(r, orElse));
        }
        return this;
    }

    /*** ++++++++++ 映射赋值，来源数据类型2 ++++++++++ ***/

    public <V> BiFunctionBulider<T, U, R> tMapper(BiConsumer<R, V> biConsumer, Function<U, V> function) {
        list.add(r -> biConsumer.accept(r, function.apply(u)));
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> tMapper(boolean accept, BiConsumer<R, V> biConsumer, Function<U, V> function) {
        if (accept) {
            list.add(r -> biConsumer.accept(r, function.apply(u)));
        }
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> tMapper(BiConsumer<R, V> biConsumer, Function<U, V> function, V orElse) {
        if (null == function) {
            list.add(r -> biConsumer.accept(r, orElse));
        } else {
            list.add(r -> biConsumer.accept(r, function.apply(u)));
        }
        return this;
    }


    public <V> BiFunctionBulider<T, U, R> tMapper(boolean accept, BiConsumer<R, V> biConsumer, Function<U, V> function, V orElse) {
        if (accept) {
            list.add(r -> biConsumer.accept(r, function.apply(u)));
        } else {
            list.add(r -> biConsumer.accept(r, orElse));
        }
        return this;
    }

    /**
     * 开始构建
     *
     * @return
     */
    public R build() {
        R r = supplier.get();
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(r));
        return r;
    }


    /**
     * 开始构建
     *
     * @return
     */
    public R build(List<Consumer<R>> list) {
        R r = supplier.get();
        Optional.of(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(item -> item.accept(r));
        return r;
    }

}

五、基于Java的 Predicate实现的构建者

package com.function.bulider;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class PredicateBulider<T> {

    private T t;

    private List<Predicate<T>> list = new ArrayList<>();

    /**
     * 获取判断列表
     *
     * @return
     */
    public List<Predicate<T>> getList() {
        return list;
    }

    public PredicateBulider(T t) {
        this.t = t;
    }

    /**
     * 获取判断的函数
     *
     * @param <T>
     * @return
     */
    public static <T> PredicateBulider<T> of(T t) {
        return new PredicateBulider<>(t);
    }

    /**
     * @param function 判断的字段
     * @param value    值
     * @param <V>      判断的字段类型
     * @return
     */
    public <V> PredicateBulider<T> width(Function<T, V> function, V value) {
        if (function.apply(t) == null) {
            list.add(t -> false);
            return this;
        }
        list.add(t -> function.apply(t).equals(value));
        return this;
    }


    /**
     * and 判断
     *
     * @param function
     * @param v1
     * @param v2
     * @param <V1>
     * @param <V2>
     * @return
     */
    public <V1, V2> PredicateBulider<T> and(Function<T, V1> function, V1 v1, V2 v2) {
        if (function.apply(t) == null) {
            list.add(t -> false);
            return this;
        }
        list.add(t -> (function.apply(t).equals(v1)) && (function.apply(t).equals(v2)));
        return this;
    }

    /**
     * or 判断
     *
     * @param function
     * @param v1
     * @param v2
     * @param <V1>
     * @param <V2>
     * @return
     */
    public <V1, V2> PredicateBulider<T> or(Function<T, V1> function, V1 v1, V2 v2) {
        if (function.apply(t) == null) {
            list.add(t -> false);
            return this;
        }
        list.add(t -> (function.apply(t).equals(v1)) || (function.apply(t).equals(v2)));
        return this;
    }

    /**
     * 非判断
     *
     * @param function 判断的字段
     * @param value    值
     * @param <V>      判断的字段类型
     * @return
     */
    public <V> PredicateBulider<T> no(Function<T, V> function, V value) {
        if (function.apply(t) == null) {
            list.add(t -> false);
            return this;
        }
        list.add(t -> (!function.apply(t).equals(value)));
        return this;
    }


    /**
     * 异或判断
     *
     * @param function
     * @param v1
     * @param v2
     * @param <V1>
     * @param <V2>
     * @return
     */
    public <V1, V2> PredicateBulider<T> xor(Function<T, V1> function, V1 v1, V2 v2) {
        if (function.apply(t) == null) {
            list.add(t -> false);
            return this;
        }
        list.add(t -> (function.apply(t).equals(v1)) ^ (function.apply(t).equals(v2)));
        return this;
    }


    /**
     * 开始构建，获取判断值
     *
     * @return
     */
    public boolean build() {
        if (t == null) {
            throw new RuntimeException("判断值不能为空");
        }
        return list.stream().reduce(x -> true, Predicate::and).test(t);
    }


}
Kotlin 函数式编程（Kotlin Functional Programming）
AI天才研究院
09-14 1万+
Kotlin函数式编程 （KotlinFunctionalProgramming） 陈光剑 1.函数式概述6 1.1.函数式简史6 1.2.函数式编程语言家族7 1.2.1.概述7 1.2.2.函数式编程语言介绍8 1.3.函数式编程的特征10 1.3.1.函数是"第一等公民"（First-classandhigher-order...
基于java的健康管理平台设计与实现(含源文件)
【完整】
03-07 1万+
欢迎添加微信互相交流学习哦！ 项目源码：https://gitee.com/oklongmm/biye 面向特定群体的健康管理平台设计与实现 摘要 随着网络技术的不断发展，网站的开发与运用变得更加广泛。这次采用java语言SSH框架(Spring，Struts，Hibernate)设计并实现了面向特定群体的健康管理平台。该网站主要有教师饮食管理、教师健康日志、教师体检管理、疾病预测评估等功能模块。通过该网站，教师可以更好的关注自己的体检状况以及最近的身体状况，根据自身情况调整饮食，睡眠等生活习惯，并
Java之函数编程
panjican的博客
07-25 452
前言 本系列文章为在《告别996，开启Java高效编程之门》学习过程中的学习笔记和课外资料补充，希望可以方便自己和其他需要的同学查阅。 Lambda表达式简介 ①Java8引入的函数式编程风格； ②可以理解为一种匿名函数的代替； ③通过行为参数传递代码。 Lambda表达式的形式 (parameters) -> expression (parameters) -> { stat...
深入理解Java中Functionl Interface
扬帆舟的博客
02-28 2833
在上一篇《深入理解Java双冒号(::)运算符的使用》的结尾，讲到了Functionl Interface。 Functionl Interface：函数式接口（或称功能接口），它是只包含一个抽象方法的接口，它们只能显示一个功能。从Java 8开始，lambda表达式可以用来表示函数式接口的实例。函数接口可以有任意数量的默认方法。例如：Runnable、ActionListener和Compara...
Java高频面试基础知识点整理
热门推荐
张彦峰的博客
11-04 167万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
基于Java的连连看游戏设计与实现(含源文件)
【完整】
03-08 7203
欢迎添加微信互相交流学习哦！ 项目源码：https://gitee.com/oklongmm/biye 毕业设计（论文）任务书 第1页 毕业设计（论文）题目： 基于Java的连连看游戏设计与实现 毕业设计（论文）要求及原始数据（资料）： 1．简述Java游戏开发现状和走向； 2．了解图形用户界面的概念； 3．熟练掌握Java的事件处理机制； 4．掌握Java小程序的工作原理和使用方法； 5．了解AWT的基本体系结构，掌握窗口的基本原理； 6. 掌握几种布局管理器的使用方法； 7. 了解Sw...
【精品毕设推荐】基于Java EE平台项目管理系统的设计与实现
tyler的博客
05-01 7514
在这个系统中我综合应用了MySQL、Servlet、JSP等知识。网页界面的结构设计以实用性出发，具有易于操作、简洁、方便等特点。在设计中，首先，运用HTML语言对网站的静态页面进行精细的加工并且在网站的美工方面取得了良好的效果。其次，对于Java编程、JSP的动态编程以及MySQL数据库进行努力学习和大量实践，并运用到了网站的建设中。
从函数式编程到声明式UI
移动端开发干货分享
03-14 3014
1.声明式UI的现状 早期的前端UI一直使用HTML+CSS+JavaScript这一经典的开发范式。HTML和CSS负责页面的布局和样式，JavaScript负责逻辑，命令式地操作Dom完成各种行为。之后不断涌现出的JQuery等各种组件库，也只是围绕Dom的操作进行了一些封装，并没用改变这种命令式操作Dom的模式。 直到React的出现，创造性地提成了声明式UI的概念才彻底颠覆了命令式的开发...
基于Java的健身房管理系统的设计与实现(附源码论文资料)
专业的计算机毕业设计指南
09-04 9141
健身俱乐部管理系统主要由六个模块组成，即人事资料模块、预约管理模块、器材管理模块、会员管理模块、系统管理模块。运行本系统先由登陆界面窗口进入用户权限认证窗口，通过用户名和口令验证的用户方可进入系统主窗口进行浏览与操作。 会员管理子系统:包括会员个人信息的修改、会员的增加和删除、会员信息查询以及会员卡的管理。 预约管理子系统:包括健身预约信息的录入、和删除。 人事资料管理子系统:包括人事资料的添加、删除、修改功能。器材管理子系统:包括器材信息的录入、增加和删除、修改、产品信息查询。考勤、工资
【Java毕业设计】基于JavaWeb的旅游论坛管理系统
Zhangsama1的博客
06-06 8912
随着社会的进步、服务行业的服务水平不断发展与提高，宾馆、酒店、旅游等服务行业的信息量和工作量日益变大，而传统的人工管理方式已经远远不能满足现在旅游的服务方式[1]。21世纪以来，随着科学技术的飞速发展，计算机及其相关软件已经成为人们日常生活与工作中不可或缺的重要工具。在这个信息时代，人们对信息的要求日益增高，传统的信息处理方式已难以满足现代社会的需求。
Functional-Java:Java中的函数式编程风格
05-13
函数式编程是其类型系统中的佼佼者，它允许在编译时进行许多检查。 Java也具有相同的机制，但是在本机使用中，它比类似物弱得多。 该库提供了使用Java进行更多检查的机会（主要是针对泛型类型）。 在函数式编程中...
基于Java的easyAi傻瓜式Java AI框架.zip
06-15
在“基于Java的EasyAI傻瓜式Java AI框架.zip”压缩包中，包含的主要内容可能是源代码（code）文件，这些文件展示了如何使用EasyAI框架来构建人工智能应用。下面将详细介绍EasyAI框架的关键特性以及如何利用它进行...
java课程设计：基于java实现的单机五子棋游戏的源代码.zip
09-11
在本Java课程设计中，学生将学习到如何利用Java编程语言来实现一个单机版的五子棋游戏。五子棋是一种策略性两人棋类游戏，玩家需要在棋盘上放置黑白两色的棋子，目标是连成五个棋子以获得胜利。这个项目旨在锻炼学生...
Scala函数式编程
03-18
所以，当你读完本书，做完习题后，虽然你的应用开发能力并不会直接提升，但你会体会到构建函数式语言和框架时的难点和取舍，从而增进你的框架开发和语言设计的能力。 　——ThoughtWorks Lead Consultant 杨博 　这...
Scala与Clojure函数式编程模式：Java虚拟机高效编程1
08-03
这本书适合有编程基础，对函数式编程感兴趣的读者，无论你是Java开发者还是对新编程范式好奇的学习者，都可以从中了解到如何在Scala和Clojure中应用函数式编程来提高代码质量和效率。 【结论】 随着大数据时代的...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 634
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1123
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 777
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 458
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java实现绘制函数图像的在线视频教程
资源摘要信息: "本资源主要包含了两个部分：一是实现绘制函数f(x)=x*x图像的Java源码，二是构建Java在线视频源码和Java手机网站源码，这两个项目可以作为学习Java实战项目案例的重要参考。" 一、Java绘制函数图像的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值