java 8 stream 小結

時間 2019-11-12

標籤 java stream 小結欄目 Java 简体版

原文原文鏈接

先上stream源碼，也就這些方法，慢慢消化。java

stream源碼

package java.util.stream;

import ......

public interface Stream<T> extends BaseStream<T, Stream<T>> {

    //過濾方法，傳入一個判斷行爲
    Stream<T> filter(Predicate<? super T> predicate);

    //接受一個Lambda，這個函數會被應用到每一個元素上，並將其映射成一個新的元素
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    IntStream mapToInt(ToIntFunction<? super T> mapper);
    LongStream mapToLong(ToLongFunction<? super T> mapper);
    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
    //
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
    //返回一個元素各異(根據流所生成元素的hashCode和equals方法實現)的流
    Stream<T> distinct();
    //按照目標對象的天然排序(Natural Order)方式進行排序,且目標對象類型必須實現Comparable接口
    Stream<T> sorted();
    //傳入一個函數式接口Comparator，通比較器的比較，進行排序
    Stream<T> sorted(Comparator<? super T> comparator);

    //peek是個中間操做，它提供了一種對流中全部元素操做的方法，而不會把這個流消費掉（foreach會把流消費掉），而後你能夠繼續對流進行其餘操做
    Stream<T> peek(Consumer<? super T> action);
    
    
    Stream<T> limit(long maxSize);
    Stream<T> skip(long n);

    //forEach是並行處理的
    void forEach(Consumer<? super T> action);
    //輸出順序是定的
    void forEachOrdered(Consumer<? super T> action);
    //轉換爲數組
    Object[] toArray();  
    <A> A[] toArray(IntFunction<A[]> generator);
    //收集結果
    <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);

    //reduce 操做能夠實現從Stream中生成一個值，其生成的值不是隨意的，而是根據指定的計算模型
    T reduce(T identity, BinaryOperator<T> accumulator);
    //歸約計算，
    Optional<T> reduce(BinaryOperator<T> accumulator);
    //歸計算
    <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);
     //經過傳入的比較器，取出最小值
    Optional<T> min(Comparator<? super T> comparator);
     //經過傳入的比較器，取出最大值
    Optional<T> max(Comparator<? super T> comparator);
    //返回集合個數
    long count();

    //Stream 中只要有一個元素符合傳入的 predicate 返回true
    boolean anyMatch(Predicate<? super T> predicate);
     //Stream 中所有元素符合傳入的 predicate 返回true
    boolean allMatch(Predicate<? super T> predicate);
    //Stream 中沒有一個元素符合傳入的 predicate，返回 true
    boolean noneMatch(Predicate<? super T> predicate);
     //拿到第一對象，而且封裝在Optional中
    Optional<T> findFirst();
     //拿到任意對象，而且封裝在Optional中
    Optional<T> findAny();



     // Static factories
    public static<T> Builder<T> builder() {
        return new Streams.StreamBuilderImpl<>();
    }
    //返回一個空的Stream
    public static<T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
    }
     //經過T對象建立一個Stream
    public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }
     // Creating a stream from an array is safe
    @SafeVarargs
    @SuppressWarnings("varargs") 
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }

    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);
    }

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

    public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);
        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }
    public interface Builder<T> extends Consumer<T> {
        @Override
        void accept(T t);
        default Builder<T> add(T t) {
            accept(t);
            return this;
        }
        Stream<T> build();

    }
}

import static數組

靜態導入，方便使用；app

java.util.stream.Collectors.toList

篩選和切片

1；filteride

該操做會接受一個謂詞(一個返回 boolean的函數)做爲參數，並返回一個包括全部符合謂詞的元素的流。函數

List<Dish> vegetarianMenu = menu.stream()
        .filter(Dish::isVegetarian)
        .collect(toList());

2；distinctui

返回一個元素各異(根據流所生成元素的hashCode和equals方法實現)的流。this

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
    .filter(i -> i % 2 == 0)
    .distinct()
    .forEach(System.out::println);

3；limit截短流code

截斷流，使其元素不超過給定數量。對象

List<Dish> dishes = menu.stream()
                            .filter(d -> d.getCalories() > 300)
                            .limit(3)
                            .collect(toList());

4；skip排序

返回一個去掉了前n個元素的流。（請注意，limit(n)和skip(n)是互補的!）

List<Dish> dishes = menu.stream()
                        .filter(d -> d.getCalories() > 300)
                        .skip(2)
                        .collect(toList());

映射

1；map

接受一個Lambda，這個函數會被應用到每一個元素上，並將其映射成一個新的元素。

List<String> dishNames = menu.stream()
                                 .map(Dish::getName)
                                 .collect(toList());

2；flatMap

把一個流中的每一個值都換成另外一個流，而後把全部的流鏈接起來成爲一個流。

List<String> uniqueCharacters =
    words.stream()
         .map(w -> w.split(""))
         .flatMap(Arrays::stream)
         .distinct()
         .collect(Collectors.toList());

查找和匹配

1；anyMatch

「流中是否有一個元素能配給定的謂詞」

if(menu.stream().anyMatch(Dish::isVegetarian)){
    System.out.println("The menu is (somewhat) vegetarian friendly!!");
}

2；allMatch

但它會看看流中的元素是否都能匹配給定的謂詞

全部菜的熱量都低於1000卡路里
boolean isHealthy = menu.stream()
                            .allMatch(d -> d.getCalories() < 1000);

3；noneMatch

它能夠確保流中沒有任何元素與給定的謂詞匹配

boolean isHealthy = menu.stream()
                            .noneMatch(d -> d.getCalories() >= 1000);

4；findAny

將返回當前流中的任意元素。

Optional<Dish> dish =
        menu.stream()
            .filter(Dish::isVegetarian)
            .findAny();

5；findFirst

找到第一個元素

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstSquareDivisibleByThree =
    someNumbers.stream()
                .map(x -> x * x)
                .filter(x -> x % 3 == 0)
                .findFirst(); // 9

reduce歸約

reduce接受兩個參數:

一個初始值，這裏是0;
一個BinaryOperator<T>來將兩個元素結合起來生一個新值。

int product = numbers.stream().reduce(1, (a, b) -> a * b);

max&min

//max
Optional<Integer> max = numbers.stream().reduce(Integer::max);

//min
Optional<Integer> min = numbers.stream().reduce(Integer::min);

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。