java8-Stream

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        }).start();

@FunctionalInterface

只允许有一个抽象方法，例如Runable和Callable接口。

@FunctionalInterface
public interface Runnable {

    public abstract void run();
}

@FunctionalInterface
public interface Callable {
  
    V call() throws Exception;
}

继承关系如图所示

public interface AutoCloseable {

    void close() throws Exception;
}

public interface BaseStream>
        extends AutoCloseable {
         
    Iterator iterator();
  
    Spliterator spliterator();
      
    boolean isParallel();
  
    S sequential();
    
    S parallel();
    
    S unordered();
  
    S onClose(Runnable closeHandler);
   
    @Override
    void close();
}

public interface Stream extends BaseStream> {

    Stream filter(Predicate predicate);

     Stream map(Function mapper);
 
    IntStream mapToInt(ToIntFunction mapper);
 
    LongStream mapToLong(ToLongFunction mapper);

    DoubleStream mapToDouble(ToDoubleFunction mapper);
    
     Stream flatMap(Function> mapper);

    IntStream flatMapToInt(Function mapper);

    LongStream flatMapToLong(Function mapper);
  
    DoubleStream flatMapToDouble(Function mapper);

    Stream distinct();

    Stream sorted();
 
    Stream sorted(Comparator comparator);

    Stream peek(Consumer action);

    Stream limit(long maxSize);

    Stream skip(long n);

    void forEach(Consumer action);

    void forEachOrdered(Consumer action);
    
    Object[] toArray();

     A[] toArray(IntFunction generator);

    T reduce(T identity, BinaryOperator accumulator);

    Optional reduce(BinaryOperator accumulator);

     U reduce(U identity,
                 BiFunction accumulator,
                 BinaryOperator combiner);


     R collect(Supplier supplier,
                  BiConsumer accumulator,
                  BiConsumer combiner);

     R collect(Collector collector);


    Optional min(Comparator comparator);

    Optional max(Comparator comparator);

    long count();

    boolean anyMatch(Predicate predicate);

    boolean allMatch(Predicate predicate);

    boolean noneMatch(Predicate predicate);
    
    Optional findFirst();

    Optional findAny();

    public static Builder builder() {
        return new Streams.StreamBuilderImpl<>();
    }


    public static Stream empty() {
        return StreamSupport.stream(Spliterators.emptySpliterator(), false);
    }

    public static Stream of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }

    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static Stream of(T... values) {
        return Arrays.stream(values);
    }
 
    public static Stream iterate(final T seed, final UnaryOperator f) {
        Objects.requireNonNull(f);
        final Iterator iterator = new Iterator() {
            @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);
    }


    public static  Stream concat(Stream a, Stream b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator) a.spliterator(), (Spliterator) b.spliterator());
        Stream stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }


    public interface Builder extends Consumer {


        @Override
        void accept(T t);

        default Builder add(T t) {
            accept(t);
            return this;
        }

        Stream build();

    }
}

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

@FunctionalInterface
public interface Consumer {

    void accept(T t);
       
    default Consumer andThen(Consumer after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

public interface Builder extends Consumer {

        @Override
        void accept(T t);

        default Builder add(T t) {
            accept(t);
            return this;
        }

        Stream build();

    }