@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

@FunctionalInterface
public interface Isort {
    public int add(int a,int b);
}

package study.base.oop.interfaces.functional;

import java.util.Random;

@FunctionalInterface
public interface Isort {
    /**
     * 1.允许定义公共静态属性
     * 2.允许默认方法
     * 3.允许私有方法(私有，静态私有)
     */
    public static int SORT_TYPE_ASC=1;
    public static int SORT_TYPE_DESC=2;
    
    //私有静态
    private static int rand() {
        return (new Random()).nextInt(100);
    }
    
    //私有方法
    private void testPrivate() {
        System.out.printf("生车一个随机数%d\n", rand());
    }
    
    //默认方法
    default void doSomething(int a,int b) {
        testPrivate();
        System.out.printf("两个参数分别是%d,%d",a,b);
    }
    //公共抽象方法 -- 这是函数式接口对外暴露的唯一方法
    public int add(int a,int b);
    
}    

@FunctionalInterface
public interface Function<T, R> {
}

//实现类
public class Sort {
    public int add(int a, int b) {
        int total= a+b;
        System.out.println("虽然不是函数式实现，但是方法同约定方法一样的结果："+total);
        return total;
    }
}

//用于演示基于构造函数引用
@FunctionalInterface
public interface IFace {
    public Face show(int a,int b);
}

public class Face {
    int a;
    int b;
    public Face(int a,int b) {
        this.a=a;
        this.b=b;
    }
    
    public void write() {
        System.out.println(a+b);
    }
}

public class StudentSortImpl implements Isort {

    @Override
    public int add(int a, int b) {
        int total = a + b;
        System.out.println(total);
        this.doSomething(a,b);
        return total;
    }

    public static void main(String[] args) {
        // 1.0 函数式接口的传统实现-类实现
        System.out.println("1.函数式接口的实现方式一:实现类");
        Isort sort = new StudentSortImpl();
        sort.add(10, 20);

        // 函数式接口的实现二-朗打方式
        System.out.println("2.函数式接口的实现方式一:朗打表达式");
        // 2.1 有返回的情况下，注意不要return语句,只能用于单个语句的
        // 如果只有一个参数，可以省掉->前的小括弧
        // 如果有返回值，某种情况下，也可以省略掉后面的花括弧{}
        // 有 return的时候
        // a->a*10
        // (a)->{return a*10} 要花括弧就需要加return
        // (a,b)->a+b
        // (a,b)->{return a+b;}
        Isort sort2 = (a, b) -> a + b;
        Isort sort3 = (a, b) -> {
            return a * 10 + b;
        };

        // 2.2 有没有多条语句都可以使用 ->{}的方式
        Isort sort4 = (a, b) -> {
            a += 10;
            return a + b;
        };
        
        int a=10;
        int b=45;
        int total=sort2.add(a, b)+sort3.add(a, b)+sort4.add(a, b);
        System.out.println("总数="+total);

        // 3 使用 new+匿名函数的方式来实现
        System.out.println("3.函数式接口的实现方式一:匿名类");
        Isort sort5 = new Isort() {
            @Override
            public int add(int a, int b) {
                int total = a * a + b;
                System.out.println(total);
                return total;
            }

        };
        sort5.add(8, 2);

        // 4.0 基于方法引用-利用已有的方法，该方法必须结构同接口的方式一致
        // 在下例中，从另外一个类实例中应用，而该实例仅仅是实现了方法，但是没有实现接口
        // 可以推测：编译的时候，通过反射或者某些方式实现的。具体要看编译后的字节码
        System.out.println("4.函数式接口的实现方式一:方法引用");
        Sort otherClassSort=new Sort();
        Isort methodSort = otherClassSort::add;
        methodSort.add(90, 90);
        
        // 5.0 基于构造函数
        // 这种方式下，要求构造函数返回的对象类型同函数接口的返回一致即可，当然参数也要一致
        System.out.println("5.函数式接口的实现方式一:构造函数引用");
        IFace conSort=Face::new;
        
        Face face=conSort.show(10, 90);
        face.write();

        //小结：基于方法和基于构造函数的实现，应该仅仅是为了stream和函数式服务，和朗打没有什么关系
        //这个最主要是为了编写一个看起来简介的表达式。
    }

}

Stream<T>是一个支持顺序和并行聚合操作的元素序列。以下示例展示了如何使用Stream和IntStream执行聚合操作：

java
int sum = widgets.stream()  
                .filter(w -> w.getColor() == RED)  
                .mapToInt(w -> w.getWeight())  
                .sum();

在这个示例中，widgets是一个Collection<Widget>。我们通过Collection.stream()方法创建了一个Widget对象的流，然后使用filter方法过滤出只有红色的Widget，接着将其转换为一个包含每个红色Widget重量的int值流。最后，对这个流进行求和操作以得到总重量。
除了Stream（一个对象引用的流）之外，还有针对原始类型的专门化，如IntStream、LongStream和DoubleStream，所有这些都被称为“流”，并遵守此处描述的特征和限制。

为了执行计算，流操作被组合成一个流管道。流管道由一个源（可能是数组、集合、生成器函数、I/O通道等）、零个或多个中间操作（将流转换为另一个流，如Stream.filter(Predicate)）和一个终端操作（产生结果或副作用，如Stream.count()或Stream.forEach(Consumer)）组成。流是惰性的；只有在启动终端操作时才会对源数据进行计算，并且只有在需要时才会消耗源元素。
流实现被允许在优化结果计算方面有很大的自由度。例如，如果流实现可以证明从流管道中省略某些操作（或整个阶段）不会影响计算结果，那么它可以自由地省略这些操作（或整个阶段），以及省略行为参数的调用。这意味着除非另有说明（如由终端操作forEach和forEachOrdered指定），否则行为参数的副作用可能不会总是被执行，因此不应依赖它们。

集合和流虽然表面上有一些相似之处，但它们有不同的目标。集合主要关注于其元素的高效管理和访问。相比之下，流不提供直接访问或操作其元素的方式，而是关注于声明性地描述其源和将对其源执行的聚合计算操作。然而，如果提供的流操作不提供所需的功能，可以使用iterator()和spliterator()操作进行受控遍历。

像上面的“widgets”示例这样的流管道可以被视为对流源的查询。除非源被明确设计为支持并发修改（如ConcurrentHashMap），否则在查询流源时修改它可能会导致不可预测或错误的行为。

大多数流操作接受描述用户指定行为的参数，如上面mapToInt中传递的lambda表达式w -> w.getWeight()。为了保持正确的行为，这些行为参数：
    必须是非干扰性的（它们不修改流源）；
    在大多数情况下必须是无状态的（它们的结果不应依赖于在执行流管道期间可能更改的任何状态）。

这样的参数始终是功能接口（如java.util.function.Function）的实例，并且经常是lambda表达式或方法引用。除非另有说明，否则这些参数必须非空。

一个流应该只被操作（调用中间或终端流操作）一次。这排除了例如“分叉”流的情况，即同一个源同时供给两个或多个管道，或对同一流进行多次遍历。如果流实现检测到流正在被重用，它可能会抛出IllegalStateException。但是，由于某些流操作可能会返回接收器本身而不是新的流对象，因此可能无法在所有情况下检测到重用。

流具有close()方法并实现AutoCloseable接口。在流关闭后对其进行操作将抛出IllegalStateException。大多数流实例在使用后实际上不需要关闭，因为它们是由集合、数组或生成函数支持的，这些不需要特殊的资源管理。通常，只有其源是I/O通道（如Files.lines(Path)返回的流）的流才需要关闭。如果流需要关闭，则必须在try-with-resources语句或类似的控制结构中将其作为资源打开，以确保在操作完成后及时关闭。

流管道可以顺序执行或并行执行。这是流的属性。流在创建时可以选择顺序执行或并行执行（例如，Collection.stream()创建顺序流，而Collection.parallelStream()创建并行流）。可以通过sequential()或parallel()方法修改执行模式的选择，并通过isParallel()方法查询。

1.流是一个支持顺序和并行聚合操作的元素序列。

2.流管道-由一个源（可能是数组、集合、生成器函数、I/O通道等）、零个或多个中间操作（将流转换为另一个流，如Stream.filter(Predicate)）和一个终端操作（产生结果或副作用，如Stream.count()或Stream.forEach(Consumer)）组成

3.流是惰性(lazy(的-只有在启动终端操作时才会对源数据进行计算，并且只有在需要时才会消耗源元素。（参考了另外一些资料，可以概述为：流管道的操作是比较智能高效，知道中止、知道优化，并非每个中间都会执行）

注：lazy“惰性“的翻译可能值得商榷，也是翻译为"延迟"更好一些。这个含义大体同spring中用于bean上@lazy注解，行为上也是相似的。

4.其它一些注意事项：一个流应该只被操作（调用中间或终端流操作）一次；只有其源是I/O通道（如Files.lines(Path)返回的流）的流才需要关闭；

5.流参数-应该必须是非干扰性的，在大多数情况下必须是无状态的