1. @FunctionalInterface
  2. public interface Consumer<T> {
  4.     void accept(T t);
  6.     default Consumer<T> andThen(Consumer<? super T> after) {
  7.         Objects.requireNonNull(after);
  8.         return (T t) -> { accept(t); after.accept(t); };
  9.     }
  10. }

核心方法如下：

  • void accept(T t);
    • 给定对象的参数T执行定义的操作
  • default Consumer andThen(Consumer<? super T> after)
    • 对给定的参数T执行定义的操作执行再继续执行after定义的操作

      设计消费者类构造

      虽然比不上lombok @Builder 性能好， 但是差距不大。

  2. package com.chihiro.jdk8.feature.functional_interface;
  4. import com.chihiro.jdk8.feature.MonitorUtil;
  5. import com.chihiro.jdk8.feature.entity.Dummy;
  6. import com.chihiro.jdk8.feature.entity.Student;
  8. import java.util.*;
  9. import java.util.concurrent.CopyOnWriteArrayList;
  10. import java.util.function.BiConsumer;
  11. import java.util.function.Consumer;
  12. import java.util.function.Supplier;
  14. /**
  15.  * @author WeiHaiChao
  16.  * @description: 通用消费者构造实现
  17.  * @createDate 2021-08-02 1:46
  18.  **/
  19. public class GenericConsumerBuilder<T> {
  21.     /**
  22.      * 消费者实例
  23.      */
  24.     private final Supplier<T> instantiate;
  26.     /**
  27.      * 存储消费者每一个行为
  28.      */
  29.     private final List<Consumer<T>> consumers = new CopyOnWriteArrayList<>();
  31.     /**
  32.      * 构造函数实例化 消费者实例
  33.      *
  34.      * @param instantiate 消费者实例
  35.      */
  36.     public GenericConsumerBuilder(Supplier<T> instantiate) {
  37.         this.instantiate = instantiate;
  38.     }
  40.     /**
  41.      * @param instantiate 消费者实例
  42.      * @param <T>         消费者类型
  43.      * @return 实例对象
  44.      */
  45.     public synchronized static <T> GenericConsumerBuilder<T> of(T instantiate) {
  46.         return new GenericConsumerBuilder<>(() -> instantiate);
  47.     }
  49.     /**
  50.      * @param instantiate 消费者实例
  51.      * @param <T>         消费者类型
  52.      * @return 实例对象
  53.      */
  54.     public synchronized static <T> GenericConsumerBuilder<T> of(Supplier<T> instantiate) {
  55.         return new GenericConsumerBuilder<>(instantiate);
  56.     }
  58.     /**
  59.      * 操作给定给定消费者的参数执行此操作
  60.      *
  61.      * @param consumerBehavior 消费者的行为
  62.      * @param consumerChange   消费者的改变
  63.      * @param <U>              给定消费者的改变
  64.      * @return 消费者
  65.      */
  66.     public synchronized <U> GenericConsumerBuilder<T> action(U consumerChange, BiConsumer<T, U> consumerBehavior) {
  67.         Consumer<T> setOperationFunction = instance -> consumerBehavior.accept(instance, consumerChange);
  68.         consumers.add(setOperationFunction);
  69.         return this;
  70.     }
  72.     /**
  73.      * 操作给定给定消费者的参数执行此操作
  74.      * 并不实用
  75.      *
  76.      * @param consumerBehaviors 消费者的改变
  77.      * @param <U>               给定消费者的改变
  78.      * @return 消费者
  79.      */
  80.     @Deprecated
  81.     private synchronized <U> GenericConsumerBuilder<T> action(U consumerChange, BiConsumer<T, U>... consumerBehaviors) {
  82.         return action(consumerChange, consumerBehaviors);
  83.     }
  85.     /**
  86.      * 操作给定给定消费者的参数执行此操作
  87.      *
  88.      * @param consumerChange 消费者的改变
  89.      * @param <U>            给定消费者的改变
  90.      * @return 消费者
  91.      */
  92.     @Deprecated
  93.     public synchronized <U> GenericConsumerBuilder<T> action(U consumerChange, BiConsumer<T, U> consumerBehavior1, BiConsumer<T, U> consumerBehavior2) {
  94.         Consumer<T> setOperationFunction = null;
  95.         List<BiConsumer<T, U>> consumerList = Arrays.asList(consumerBehavior1, consumerBehavior2);
  96.         BiConsumer<T, U> consumer = consumerList.get(0);
  97.         for (int i = 1; i < consumerList.size(); i++) {
  98.             BiConsumer<T, U> tuBiConsumer = consumerList.get(i);
  99.             setOperationFunction = instance -> consumer.andThen(tuBiConsumer).accept(instance, consumerChange);
  100.         }
  101.         consumers.add(setOperationFunction);
  102.         return this;
  103.     }
  105.     /**
  106.      * 建立改变行为后的供给型消费者
  107.      *
  108.      * @return 变更的消费者
  109.      */
  110.     public synchronized T build() {
  111.         T instance = instantiate.get();
  112.         consumers.forEach(data -> data.accept(instance));
  113.         consumers.clear();
  114.         return instance;
  115.     }
  117.     /**
  118.      * 建立改变行为后的消费者
  119.      *
  120.      * @return 变更的消费者
  121.      */
  122.     public synchronized Optional<T> newBuild() {
  123.         T instance = instantiate.get();
  124.         consumers.forEach(data -> data.accept(instance));
  125.         consumers.clear();
  126.         return Optional.ofNullable(instance);
  127.     }
  130.     /**
  131.      * 建立改变行为后的消费者
  132.      *
  133.      * @param instanceSupplier 供给型消费者实例
  134.      * @return 变更的消费者
  135.      * @throws ToolException 实例为空
  136.      */
  137.     public synchronized T build(Supplier<T> instanceSupplier) throws ToolException {
  138.         T instance = SupplierTool.resolve(instanceSupplier).orElseThrow(() -> new ToolException("instance not null"));
  139.         consumers.forEach(data -> data.accept(instance));
  140.         consumers.clear();
  141.         return instance;
  142.     }
  144.     /**
  145.      * 建立改变行为后的供给型消费者
  146.      *
  147.      * @param instanceSupplier 供给型消费者实例
  148.      * @return 变更的消费者
  149.      * @throws ToolException 实例为空
  150.      */
  151.     public synchronized Optional<T> newBuild(Supplier<T> instanceSupplier) throws ToolException {
  152.         T instance = SupplierTool.resolve(instanceSupplier).orElseThrow(() -> new ToolException("instance not null"));
  153.         consumers.forEach(data -> data.accept(instance));
  154.         consumers.clear();
  155.         return Optional.ofNullable(instance);
  156.     }
  159.     private static void testLombokBuilder() {
  160.         MonitorUtil.start();
  161.         List<Student> studentList = new ArrayList<>();
  162.         for (int i = 0; i < 999999; i++) {
  163.             Student student = Student.builder().age(i).name("sutnde" + i)
  164.                     .a(i).b(i).c(i).d(i).e(i).f(i).g(i).h(i).i(i).j(i).k(i)
  165.                     .build();
  166.             studentList.add(student);
  167.         }
  168.         MonitorUtil.finish();
  169.     }
  171.     private static void testGenericConsumerBuilder() {
  172.         MonitorUtil.start();
  173.         List<Dummy> dummys = new ArrayList<>();
  174.         for (int i = 0; i < 999999; i++) {
  175.             Dummy dummy = GenericConsumerBuilder.of(Dummy::new)
  176.                     .action("dummy" + i, Dummy::setName)
  177.                     .action(i, Dummy::setAge)
  178.                     .build();
  179.             dummys.add(dummy);
  180.         }
  181.         MonitorUtil.finish();
  182.     }
  184.     /**
  185.      * test :
  186.      * lombok Builder                               1:耗时1902ms 2:耗时1791ms 3:耗时1910ms 4: 耗时1907ms 5:耗时1837ms
  187.      * GenericConsumerBuilder LinkedList            1:耗时2107ms 2:耗时2154ms 3:耗时2759ms 4: 耗时2221ms 5:耗时2274ms
  188.      * GenericConsumerBuilder ArrayList             1:耗时2552ms 2:耗时2559ms 3:耗时2589ms 4: 耗时2541ms 5:耗时2615ms
  189.      * GenericConsumerBuilder Vector                1:耗时2498ms 2:耗时2535ms 3:耗时2503ms 4: 耗时2563ms 5:时2584ms
  190.      * GenericConsumerBuilder CopyOnWriteArrayList  1:耗时2080ms 2:耗时2095ms 3:耗时2053ms 4: 耗时2073ms 5:耗时2096ms
  191.      */
  192.     public static void main(String[] args) {
  193. //        testGenericConsumerBuilder();
  194. //        testLombokBuilder();
  195. //        Optional<Dummy> dummyOptional = GenericConsumerBuilder.of(Dummy::new)
  196. //                .action("23", Dummy::setName)
  197. //                .action(112, Dummy::setAge)
  198. //                .newBuild();
  200.     }
  203. }