@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Runnable r1 = () -> System.out.println("hello lambda");
r1.run();

/**
 * 自己定义了一个函数式接口
 */
@FunctionalInterface
public interface MyFunction {
    public abstract Integer run(Integer x ,Integer y,Integer z);
}

MyFunction c=(x,y,z)->x+y-z;
System.out.println(c.run(1,2,3));

@Data
public class Emp {
    private String address;
    private String name;
    private Integer age;
    public Emp() {

    }
    public Emp(String address) {
        this.address = address;
    }
    public Emp(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public Emp(String address, String name, Integer age) {
        super();
        this.address = address;
        this.name = name;
        this.age = age;
    }
    // 演示如果调用静态方法
    public static Boolean compareOfStatic(String a,String b){
        return b.equalsIgnoreCase(a);
    }
    // 演示如果调用对象的方法
    public Boolean compareOfClass(String a){
        return a.equalsIgnoreCase(this.address);
    }
}

/**
     * 测试类的静态方法引用
     * 类::静态方法名 = Emp::compareOfStatic
     */
    @Test
    public void testStaticMethod(){
        BiFunction<String,String,Boolean> biFunction =Emp::compareOfStatic;
        Boolean ren=  biFunction.apply("b","b");
        System.out.println(ren);
    }


    /**
     * 类::实例方法名=Emp::compareOfClass
     */
    @Test
    public void testClassMethod(){
        BiFunction<Emp,String,Boolean> biFunction = Emp::compareOfClass;
        Emp first=new Emp("a","b",1);
        Boolean ren=  biFunction.apply(first,"b");
        System.out.println(ren);
    }


    /**
     * 对象::实例方法名=Emp::compareOfClass
     */
    @Test
    public void testObjectMethod(){
        Emp first=new Emp("a","b",1);
        Function<String,Boolean> fun= first::compareOfClass;

        Boolean ren=  fun.apply("b");
        System.out.println(ren);
    }

/**
     * 演示了用构造函数创建
     * 1：无参数
     * 2: 一个参数
     * 3: 两个参数
     * 4: 三个参数
     */
    @Test
    public void testStructureFunction(){
        Supplier<Emp> noArg= Emp::new;
        System.out.println(noArg.get());

        Function<String,Emp> oneArg=Emp::new;
        System.out.println(oneArg.apply("地址"));

        BiFunction<String,Integer,Emp> towArg=Emp::new;
        System.out.println(towArg.apply("地址",1));

        //三个参数，为什么Java不提供三个参数的呢？
        // 实际上的用法很少会用到三个参数，因为感觉像做递归，fist与next
        // 如果真要做三个以上参数，可以参考MyFunction来自己定义一个函数接口
    }

/**
 * 自己定义了一个函数式接口
 */
@FunctionalInterface
public interface MyFunction {
    public abstract Integer run(Integer x ,Integer y,Integer z);
}

MyFunction c=(x,y,z)->x+y-z;
System.out.println(c.run(1,2,3));

// 演示compose , 这个Function的返回值，是上一个的输入值
        Function<Emp,Integer> before =(emp)->emp.getName()=="tom"?1:0;
        Emp testEmp=new Emp("北京","tom1",1);
        var ren = first.compose(before).apply(testEmp);
        System.out.println(ren);

// 柯里化之前
function add(x, y) {
  return x + y;
}
add(1, 2); // 3
// 柯里化之后
function addX(y) {
  return function (x) {
    return x + y;
  };
}
addX(2)(1); // 3

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

public interface Function<T, R> {

R apply(T t);

default <V> Function<V, R> compose(Function<? super V, ? extends T> before)

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after)

static <T> Function<T, T> identity()

// 演示Function
Function<Integer,String> first=(id)->id>0?"true":"false";
System.out.println(first.apply(1));

// 演示compose , 这个Function的返回值，是上一个的输入值
Function<Emp,Integer> before =(emp)->emp.getName()=="tom"?1:0;
Emp testEmp=new Emp("北京","tom1",1);
var ren = first.compose(before).apply(testEmp);
System.out.println(ren);

// 演示andThen
Function<String,Boolean> after=str->str.equalsIgnoreCase("true")?true:false;
Boolean  afterRen= first.andThen(after).apply(1);
System.out.println(afterRen);


// 演示identity
Function<Integer,Integer> inden=  Function.identity();
Integer ren2=  inden.apply(1);
System.out.println(ren2);

IntFunction<R>,IntToDoubleFunction,IntToLongFunction,LongFunction<R>,LongToDoubleFunction,LongToIntFunction,DoubleFunction<R>,ToIntFunction<T>,ToDoubleFunction<T>,ToLongFunction<T>

// 啥水果都能放的盘子 如果没有 extends 就会报错
Plate<? extends Fruit> p=new Plate<Apple>(new Apple());

Plate<？ super Fruit>

public interface Consumer<T> {
    void accept(T t);
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Consumer<Integer> consumer=x->{
    System.out.println(x+1);
};
consumer.accept(1);

Consumer<Integer> after= x->{
    System.out.println("后期处理函数："+x);
};
consumer.andThen(after).accept(1);

2
2
后期处理函数：1

@FunctionalInterface
public interface Supplier<T> {
   T get();
}

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
   static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

UnaryOperator<Integer> dda = x -> x + 1;
System.out.println(dda.apply(10));// 11
UnaryOperator<String> ddb = x -> x + 1;
System.out.println(ddb.apply("aa"));// aa1

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
        Objects.requireNonNull(after);
        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

BiConsumer<Integer,String> biConsumer = (k,v)->{
	System.out.println("key:"+k);
	System.out.println("value:"+v);
};

biConsumer.accept(1,"beijing");

Map<String, String> map = new HashMap<>();
        map.put("a", "a");
        map.put("b", "b");
        map.put("c", "c");
        map.put("d", "d");
        map.forEach((k, v) -> {
            System.out.println(k);
            System.out.println(v);
        });

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

BiFunction<Integer,Integer,Integer> add =(x,y)->x+y;
Integer ren = add.apply(1,2);
System.out.println(ren);

Function<Integer,Integer> mod=(x)->x-1;

Integer ren2=add.andThen(mod).apply(1,2);
System.out.println(ren2);
// (1+2)-1

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

List<Integer> transactionsIds =
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum();

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

List<String> filtered = strings.stream()
    .filter(string -> !string.isEmpty())
    .collect(Collectors.toList());

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.parallelStream()
    .filter(string -> string.isEmpty())
    .count();

// supplier处理器  accumulator累加器 combiner组合器
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);

<R, A> R collect(Collector<? super T, A, R> collector);

// A 结果类型，T 中间操作类型，R 最终返回类型，一般情况下，A=R
public interface Collector<T, A, R> {
        public static<T, R> Collector<T, R, R> of(
                                              // 源数据对象类型（中间操作对象类型）
                                              Supplier<R> supplier,
                                              // T 中间操作类型
                                              BiConsumer<R, T> accumulator,
                                              //并发 合并部分结果
                                              BinaryOperator<R> combiner,
                                              // 当前收集器的特性
                                              Characteristics... characteristics) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(accumulator);
        Objects.requireNonNull(combiner);
        Objects.requireNonNull(characteristics);
        Set<Characteristics> cs = (characteristics.length == 0)
                                  ? Collectors.CH_ID
                                  : Collections.unmodifiableSet
                                      (EnumSet.of
                                       (Collector.Characteristics.IDENTITY_FINISH
                                        ,characteristics));
        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, cs);
    }


    public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
                                                 BiConsumer<A, T> accumulator,
                                                 BinaryOperator<A> combiner,
                                                 // 可选，对结果集的转换
                                                 Function<A, R> finisher,
                                                 Characteristics... characteristics) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(accumulator);
        Objects.requireNonNull(combiner);
        Objects.requireNonNull(finisher);
        Objects.requireNonNull(characteristics);
        Set<Characteristics> cs = Collectors.CH_NOID;
        if (characteristics.length > 0) {
            cs = EnumSet.noneOf(Characteristics.class);
            Collections.addAll(cs, characteristics);
            cs = Collections.unmodifiableSet(cs);
        }
        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, finisher, cs);
    }
    .................................
}

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

List<String> filtered = strings.stream()
    .filter(string -> !string.isEmpty())
    .collect(Collectors.toList());

System.out.println("筛选列表: " + filtered);

String mergedString = strings.stream()
    .filter(string -> !string.isEmpty())
    .collect(Collectors.joining(", "));

System.out.println("合并字符串: " + mergedString);

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

Random random = new Random();
random.ints().limit(10)
    .forEach(System.out::println);

String[] dd = { "a", "b", "c" };
Stream.of(dd).forEach(System.out::print);// abc

@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

Stream.iterate(0, x -> x + 1).limit(10).forEach(System.out::print);// 0123456789

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
        Objects.requireNonNull(f);
        final Iterator<T> iterator = new Iterator<T>() {
            @SuppressWarnings("unchecked")
            T t = (T) Streams.NONE;

            @Override
            public boolean hasNext() {
                return true;
            }

            @Override
            public T next() {
                return t = (t == Streams.NONE) ? seed : f.apply(t);
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                iterator,
                Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
    }

Stream.generate(() -> "x").limit(10).forEach(System.out::print);// xxxxxxxxxx

public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
}

String[] dd = { "a", "b", "c" };
Arrays.stream(dd).forEach(System.out::print);// abc

String[] dd = { "a", "b", "c" };
List list=Arrays.asList(dd);
list.stream().forEach(System.out::print);// abc

public interface Stream<T> extends BaseStream<T, Stream<T>> {
	Stream<T> filter(Predicate<? super T> predicate);
    Stream<T> distinct();
 	Stream<T> sorted();
 	Stream<T> sorted(Comparator<? super T> comparator);
 	Stream<T> peek(Consumer<? super T> action);
 	Stream<T> limit(long maxSize);
 	Stream<T> skip(long n);
	<R> Stream<R> map(Function<? super T, ? extends R> mapper);
    //下面是终端操作
    void forEach(Consumer<? super T> action);
    Optional<T> min(Comparator<? super T> comparator);
    long count();
    .........................................................
}

Stream<T> filter(Predicate<? super T> predicate);

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.stream()
    .filter(string -> string.isEmpty())
    .count();

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream()
    .map( i -> i*i)
    .distinct() //去重
    .collect(Collectors.toList());

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

public static void main(String[] args) {
  List<String> list = Arrays.asList("a1","a2","a3");

  //一对一的处理，在每个字符串后面加上test输出
  list.stream()
      .map(s->s+"test")
      .forEach(System.out::println);

  ////一对多的处理，把每个字符串拆成一个个字符，输出，这点map就无法做到。
  list.stream()
      .flatMap(s -> Stream.of(s.split("")))
      .forEach(System.out::println);
}

@Test
public void FlatMapTest(){
    String[] words = new String[]{"Hello","World"};

    //直接输出，没有做任何处理
    Stream.of(words).forEach(System.out::println);

    //map 将一个流中的每个元素做了处理，然后输出相同数量的流内容
    Stream.of(words)
            .map(s->s.length())
            .forEach(System.out::println);



    //flat实际上，将一个stream转换成两外一个stream
    Stream.of(words)
            .flatMap(s->Stream.of(s.split("")))
            .forEach(System.out::println);

    //去重复，输出HeloWrd
    String ren=Stream.of(words)
            .flatMap(s->Stream.of(s.split("")))
            .distinct()
            .collect(Collectors.joining());
    System.out.println(ren);
}

//去重复
Stream<T> distinct();
//排序
Stream<T> sorted();
//根据属性排序
Stream<T> sorted(Comparator<? super T> comparator);
//当前元素进行操作
Stream<T> peek(Consumer<? super T> action);
//截断--取先maxSize个对象
Stream<T> limit(long maxSize);
//截断--忽略前N个对象
Stream<T> skip(long n);

//去重排序
Stream.of(2,1,2,3)
    .distinct()
    .sorted()
    .forEach(System.out::println);

//给大于30岁的人，加薪300元
System.out.println("--------------------------------");
empList.stream()
    .filter(emp->emp.getAge()>30)
    .map(emp->{
        emp.setSalary(emp.getSalary()+300);
        return emp;
    })
    .forEach(System.out::println);

//用peek来处理
System.out.println("--------------------------------");
empList.stream()
    .filter(emp->emp.getAge()>30)
    .peek(emp->emp.setSalary(emp.getSalary()+300))
    .forEach(System.out::println);

Stream<T> peek(Consumer<? super T> action);

//按照年龄排序，跳过前两个，只取2个
System.out.println("--------------------------------");
empList.stream()
    .sorted(Comparator.comparing(Emp::getAge))
    .skip(2)
    .limit(2)
    .forEach(System.out::println);

System.out.println("--------------------------------");
// 数字从1开始迭代（无限流），下一个数字，是上个数字+1，忽略前5个 ，并且只取10个数字
Stream.iterate(1, x -> ++x)
    .skip(5)
    .limit(10)
    .forEach(System.out::println);

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    ....还有好多静态方法
}

//倒序
Stream.of(2,1,2,3)
    .distinct()
    .sorted(
      (o1,o2)->{
        return o2-o1;
      }
    )
    .forEach(System.out::println);

//按照名称排序
empList.stream()
    .sorted(Comparator.comparing(Emp::getAge))
    .forEach(emp->System.out.println(emp));

/**
	 传入一个Function类型的参数,keyExtractor。
	 Extractor表示提取器，这个函数用来提取一个数值，由于是接口函数，所以通过apply(c1)来提取。
	 keyExtractor.apply(c1)=Emp::getAge =emp.getAge()
*/
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
    Function<? super T, ? extends U> keyExtractor)
{
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

empList.stream()
    .sorted(Comparator.comparing(Emp::getAge,(a,b)->b-a))
    .forEach(emp->System.out.println(emp));

public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor)

public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor)

public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor)

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}

List<Emp> empList=new ArrayList();
empList.add(new Emp("海淀","小王",20,5000.0));
empList.add(new Emp("海淀","小李",50,15000.0));
empList.add(new Emp("海淀","小张",30,2000.0));
empList.add(new Emp("海淀","小赵",40,20000.0));
empList.add(new Emp("海淀","小陈",60,5500.0));
empList.add(new Emp(null,"小刘",60,5500.0));

empList.stream()
    .sorted(Comparator.comparing(Emp::getAddress).reversed())
    .forEach(emp->System.out.println(emp));

System.out.println("按照地址降序，若有空，放到最前面：" );
empList.stream()
    .sorted(Comparator.comparing(Emp::getAddress,Comparator.nullsLast(String::compareTo))
    .reversed())
    .forEach(emp->System.out.println(emp));

public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
    return new Comparators.NullComparator<>(false, comparator);
}

static final class NullComparator<T> implements Comparator<T>, Serializable {
    private static final long serialVersionUID = -7569533591570686392L;
    private final boolean nullFirst;
    // if null, non-null Ts are considered equal
    private final Comparator<T> real;

    @SuppressWarnings("unchecked")
    NullComparator(boolean nullFirst, Comparator<? super T> real) {
        this.nullFirst = nullFirst;
        this.real = (Comparator<T>) real;
    }
 ........................................................
}

@Override
public int compare(T a, T b) {
    if (a == null) {
        return (b == null) ? 0 : (nullFirst ? -1 : 1);
    } else if (b == null) {
        return nullFirst ? 1: -1;
    } else {
        return (real == null) ? 0 : real.compare(a, b);
    }
}

@Override
public Comparator<T> reversed() {
    return new NullComparator<>(!nullFirst, real == null ? null : real.reversed());
}