Java Builder 构造者模式

1 测试

package com.xu.builder;

import java.util.UUID;

public class Test {

    public static void main(String[] args) {
        Student student = Builder.of(Student::new)
                .width(Student::setId, UUID.randomUUID().toString())
                .width(Student::setName, "张三")
                .width(Student::setAge, 21)
                .build();
        System.out.println(student.toString());
    }
    
}

2 结果

Student{age=21, id='b52643be-d001-4a40-9d1b-9aa739ed6f96', name='张三', email='null'}

3 Builder.java

package com.xu;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * @author Administrator
 */
public class Builder<T> {

    private final Supplier1<T> supplier;

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

    public Builder(Supplier1<T> supplier) {
        this.supplier = supplier;
    }

    public static <T> Builder<T> of(Supplier1<T> supplier) {
        return new Builder<T>(supplier);
    }

    public <V> Builder<T> width(Consumer2<T, V> consumer, V value) {
        list.add(e -> consumer.accept(e, value));
        return this;
    }

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

    public <V> Builder<T> width(boolean accept, Consumer2<T, V> consumer, V value) {
        if (accept) {
            list.add(e -> consumer.accept(e, value));
        }
        return this;
    }

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

    public T build() {
        T t = supplier.get();
        Optional.ofNullable(list)
                .orElse(new ArrayList<>())
                .stream()
                .filter(Objects::nonNull)
                .forEach(e -> e.accept(t));
        return t;
    }

    @FunctionalInterface
    public interface Consumer2<T, V> {
        /**
         * accept 2 values
         *
         * @param t
         * @param value
         */
        void accept(T t, V value);
    }

    @FunctionalInterface
    public interface Consumer1<T> {
        /**
         * accept 1 value
         *
         * @param t
         */
        void accept(T t);
    }

    @FunctionalInterface
    public interface Supplier1<T> {

        /**
         * Gets a result.
         *
         * @return a result
         */
        T get();
    }

}

7 Java 常用函数式接口

函数式接口	定义	作用
Function<T, R>	方法	Fcuntion 接口是对接受一个 T 类型参数,返回R类型的结果的方法的抽象，通过调用apply方法执行内容。
Consumer<T>	消费者	该接口对应的方法类型为接收一个参数，没有返回值。
Supplier<T>	生产者	该接口不接受参数，但是提供一个返回值。
Predicate<T>	判断	该接口对应的方法为接收一个参数，返回一个Boolean类型值，多用于判断与过滤。

7.1 Predicate

主要使用方法	功能
boolean test(T t)	判断是否满足条件
Predicate<T> and(Predicate<? super T> other)	并且
Predicate<T> or(Predicate<? super T> other)	或者
Predicate<T> negate()	取反 test(T t)
Predicate<T> isEqual(Object targetRef)	-
Predicate not(Predicate<? super T> target)	-

@Test
public void predicate() {
    Predicate<Integer> predicate = age -> age > 24;
    Student student = new Student(23, "张三");
    System.out.println("张三大于24岁吗？" + predicate.test(student.getAge()));
}

张三大于24岁吗?false

@Test
public void predicate() {
    System.out.println(test(s -> s.length() > 24, "Hello"));
    System.out.println(or((s) -> s.length() > 5, (s1) -> s1.contains("H"), "Hello"));
    System.out.println(and((s) -> s.length() >= 5, (s1) -> s1.contains("H"), "Hello"));
    System.out.println(negate(s -> s.length() >= 5, s1 -> s1.contains("H"), "Hello"));
    System.out.println(isEqual("1", "2"));
    System.out.println(not(e -> e.toString().length() > 22, "2"));
}

boolean test(Predicate<String> predicate, String str) {
    return predicate.test(str);
}

boolean and(Predicate<String> predicate1, Predicate<String> predicate2, String str) {
    return predicate1.and(predicate2).test(str);
}

boolean negate(Predicate<String> predicate1, Predicate<String> predicate2, String str) {
    return predicate1.and(predicate2).negate().test(str);
}

boolean or(Predicate<String> predicate1, Predicate<String> predicate2, String str) {
    return predicate1.or(predicate2).test(str);
}

boolean isEqual(String str1, String str2) {
    Predicate predicate1 = Predicate.isEqual(str1);
    return predicate1.test(str2);
}

boolean not(Predicate predicate1, String str1) {
    Predicate predicate2 = Predicate.not(predicate1);
    return predicate2.test(str1);
}

false
true
true
false
false
true

7.2 Consumer

抽象方法	功能
accept(T t)	消费消息
Consumer<T> andThen(Consumer<? super T> after)	然后

package com.xu.music;

import java.util.function.Consumer;

public class Test {
	public static void main(String[] args) {
		Consumer<String> consumer = System.out::println;
		consumer.accept("随便输出一些东西");
	}
}

随便输出一些东西

7.3 Function

抽象方法	功能
R apply(T t)	T 映射为 R
Function<V, R> compose(Function<? super V, ? extends T> before)	比较
Function<T, V> andThen(Function<? super R, ? extends V> after)
Function<T, T> identity()

package com.xu.music;

import java.util.function.Function;

public class Test {
	public static void main(String[] args) {
		Function<Student, String> function = Student::getName;
		Student student = new Student(175, 23, "张三");
		String name = function.apply(student);
		System.out.println("-->" + name);
	}
}

-->张三

7.4 Supplier

抽象方法	功能
T get()	生产消息

package com.xu.music;

import java.util.function.Function;
import java.util.function.Supplier;

public class Test {
	public static void main(String[] args) {
		Student student = new Student(175, 23, "张三");
		Function<Student, Integer> function = Student::getAge;
			
		Supplier<Integer> supplier =  () -> Integer.valueOf(function.apply(student));
		System.out.println(supplier.get());
	}
}

23

7.5 UnaryOperator

函数接口	抽象方法	功能
UnaryOperator	apply(T t)	一元操作

package com.xu.music;

import java.util.function.Predicate;
import java.util.function.UnaryOperator;

public class Test {
	public static void main(String[] args) {
		Student student = new Student(175, 23, "张三");
		Predicate<Integer> predicate = age -> age > 24;
			
		UnaryOperator<Boolean> unaryOperator = uglily -> predicate.test(student.getAge());
		Boolean apply = unaryOperator.apply(true);
		System.out.println(apply);
	}
}

false

7.6 BinaryOperator

函数接口	抽象方法	功能
BinaryOperator	apply(T t, U u)	二元操作

package com.xu.music;

import java.util.function.BinaryOperator;

public class Test {
	public static void main(String[] args) {
		BinaryOperator<Integer> operator = (x, y) -> x * y;
		Integer integer = operator.apply(2, 3);
		System.out.println(integer);
	}
}

6