import java.util.Comparator;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @ClassName MyFunction
* @Author Javan
* @Date 2021/6/30 14:54
* @Description
*
* Function： 接收一個(gè)參數(shù) object
* Consumer: 接收一個(gè)參數(shù) void
* Predicate: 接收一個(gè)參數(shù) boolean
* UnaryOperator: 接收一個(gè)參數(shù) object
* BinaryOperator: 接收兩個(gè)參數(shù) object
*
**/
public class MyFunction {
public interface MyConsumer<T, U, R, S, G>{
void accept(T t,U u,R r,S s,G g);
static MyConsumer print() {
return (p1,p2,p3,p4,p5) -> System.err.println("MyConsumer print -> " + Stream.of(p1,p2,p3,p4,p5).map(String::valueOf).collect(Collectors.joining(",")));
}
}
private static Function f = ((Function) t -> t)
.andThen(t -> {
System.err.println(t);
return t + "then -> ";
}).andThen(t -> {
System.err.println(t);
return t + "then1 -> ";
}).compose(d -> {
System.err.println(d);
return d + "compose -> ";
}).compose(d -> {
System.err.println(d);
return d + "compose1 -> ";
});
/**
* 接收兩個(gè)參數(shù)返回一個(gè)參數(shù)
*/
static BiFunction<String, Integer, Long> bif = ((BiFunction) (s, i) -> 0l).andThen(t -> {
System.err.println(t);
return t + "then -> ";
});
/**
* 消費(fèi)者
* 接收一個(gè)參數(shù)所刀，然后執(zhí)行方法體潦嘶，沒(méi)有返回值.
*/
static Consumer<String> c = (d) -> System.err.println("Consumer -> " + d);
static BiConsumer<String, Integer> bc = (b, i) -> System.err.println("BiConsumer -> " + b + "-" + i);
static DoubleConsumer bbc = b -> System.err.println("DoubleConsumer -> " + b);
static IntConsumer ic = b -> System.err.println("IntConsumer -> " + b);
static LongConsumer lc = b -> System.err.println("LongConsumer -> " + b);
static MyConsumer mc = (p1,p2,p3,p4,p5) -> System.err.println("MyConsumer -> " + Stream.of(p1,p2,p3,p4,p5).map(String::valueOf).collect(Collectors.joining(",")));
/**
* 謂詞
* 接收一個(gè)參數(shù)，返回true or false.
* 就像漢語(yǔ)中的謂詞，
* 例如：
* "貓是動(dòng)物"一句中的"是"就是一個(gè)謂詞，而"貓"是客體砸烦。
* cat -> animal.containsKey(cat);
* <p>
* "3 大于 2"中"大于"是一個(gè)謂詞昙沦。
* num -> 3>2;
* <p>
* 3+1等于5
* <p>
* num -> 3+1 == 5;
*/
static Predicate<String> p = (d) -> true;
static BiPredicate<String, Integer> bp = (s, i) -> true;
/**
* 一元運(yùn)算符
*/
static UnaryOperator up = d -> d;
/**
* 二元運(yùn)算符
*/
static BinaryOperator<String> bo = (s, v) -> v;
static BinaryOperator<String> minBo = BinaryOperator.minBy(Comparator.reverseOrder());
static BinaryOperator<String> maxBo = BinaryOperator.maxBy(Comparator.reverseOrder());
static DoubleBinaryOperator dbo = (s, v) -> v;
static IntBinaryOperator ibo = (s, v) -> v;
static LongBinaryOperator lbo = (s, v) -> v;
/**
* 布爾值供應(yīng)商
* 不接受參數(shù)哈雏，在主體進(jìn)行操作返回true or false.
*/
static Supplier<Object> s = () -> new Object();
static BooleanSupplier bs = () -> true;
static IntSupplier is = () -> 1;
static DoubleSupplier ds = () -> 1d;
static LongSupplier ls = () -> 1l;
/**
* 比較大小
* v1 大于 v2返回true
*
* @param args
*/
static BiPredicate<String, String> compare = (v1, v2) -> ((Comparator<String>) Comparator.naturalOrder()).compare(v1, v2) > 0;
public static void main(String[] args) {
System.err.println("--------------------Function");
f.apply("start ");
System.err.println("--------------------Predicate");
System.err.println("Predicate -> " + p.test("1"));
System.err.println("BiPredicate -> " + bp.test("1",2));
System.err.println("--------------------UnaryOperator");
System.err.println(up.apply("1"));
System.err.println("--------------------BinaryOperator");
System.err.println("BinaryOperator -> " + bo.apply("1", "2"));
System.err.println("minBy -> " + minBo.apply("111", "2"));
System.err.println("maxBy -> " + maxBo.apply("111", "2"));
System.err.println("DoubleBinaryOperator -> " + dbo.applyAsDouble(1d, 2d));
System.err.println("IntegerBinaryOperator -> " + ibo.applyAsInt(1, 2));
System.err.println("LongBinaryOperator -> " + lbo.applyAsLong(1l, 2l));
System.err.println("--------------------Supplier");
System.err.println("Supplier -> " + s.get());
System.err.println("BooleanSupplier -> " + bs.getAsBoolean());
System.err.println("IntSupplier -> " + is.getAsInt());
System.err.println("DoubleSupplier -> " + ds.getAsDouble());
System.err.println("LongSupplier -> " + ls.getAsLong());
System.err.println("--------------------Consumer");
c.accept("1");
bc.accept("1", 2);
bbc.accept(1d);
ic.accept(1);
lc.accept(1l);
mc.accept(1,2,3,4,5);
MyConsumer.print().accept("One", "two", "three", "four", "five");
System.err.println("--------------------compare");
System.err.println(compare.test("8", "7"));
}
}
--------------------Function
start
start compose1 ->
start compose1 -> compose ->
start compose1 -> compose -> then ->
--------------------Predicate
Predicate -> true
BiPredicate -> true
--------------------UnaryOperator
1
--------------------BinaryOperator
BinaryOperator -> 2
minBy -> 2
maxBy -> 111
DoubleBinaryOperator -> 2.0
IntegerBinaryOperator -> 2
LongBinaryOperator -> 2
--------------------Supplier
Supplier -> java.lang.Object@3532ec19
BooleanSupplier -> true
IntSupplier -> 1
DoubleSupplier -> 1.0
LongSupplier -> 1
--------------------Consumer
Consumer -> 1
BiConsumer -> 1-2
DoubleConsumer -> 1.0
IntConsumer -> 1
LongConsumer -> 1
MyConsumer -> 1,2,3,4,5
MyConsumer print -> One,two,three,four,five
--------------------compare
true
Process finished with exit code 0
