Stream流-阿里云开发者社区

前言

stream流摒弃了传统便利集合的弊端，作为一个集合元素的函数模型，本身并不是一个集合，也不是数据结构，本身并不存储任何的元素或者其他地址值。Stream流的中间操作都会返回给流对象本身，多个操作可以串联成一个管道。

一、创建Stream流的三大基本步骤？

1.获取一个数据源

2.数据转换

3.执行操作获取想要的结果

ps：每次转换Stream对象不变，返回一个新的Stream对象。

二、获取流的方式

写在前面：

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口（这并不是一个函数式接口）。获取一个流非常简单，有以下几种常用的方式：

所有的 Collection 集合都可以通过 stream 默认方法获取流；

Stream 接口的静态方法 of 可以获取数组对应的流。

1.根据Collection获取流

在Java.util.Collection接口中加入了defult方法stream方法来获取流，因此其所有的实现类都可以获取流

代码如下（示例）：

public class GetStream01 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        Stream<Object> stream = list.stream();

        HashSet<Object> set = new HashSet<>();
        Stream<Object> stream1 = set.stream();

        Vector<Object> vector = new Vector<>();
        Stream<Object> stream2 = vector.stream();

    }
}

2.根据Map获取流

Map并不是Collection的子接口，加上Map的Key-Value结构不符合流元素单一的特征，因此在获取Map流时要分Key，Value，Entry等情况

代码如下（示例）：

public class GetStream02 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();

        Stream<String> keystream = map.keySet().stream();
        Stream<String> valueStream = map.values().stream();
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
    }
}

3.根据数组获取流

在数组对象中不能添加默认方法，在Stream接口中提供了静态方法of （of方法其实就是一个可变参数，所以后面当然可以接数组啦）

代码如下（示例）：

public class GetStream03 {
    public static void main(String[] args) {
        String[] array = {"肌肉猿","程序员非晚"};
        Stream<String> stream = Stream.of(array);
    }
}

三、常用方法列举

首先流模型的操作很丰富，常用的API分为两大类

延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本文章中终结方法包括 count 和 forEach 方法。

1.逐一处理：forEach

public class StreamForEach {
    public static void main(String[] args) {
        String[] array = {"肌肉猿","程序员非晚"};
        Stream<String> stream = Stream.of(array);
        stream.forEach(name-> System.out.println(name));
    }
}

-------------------------------------------------------------------------------------------------------------------
void forEach(Consumer<? super T> action);
--------------------------------------------------------------------------------------------------------------------
@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

通过查看foreach的细节，该方法接收一个Consumer接口函数，从而将每一个流元素交给该函数处理。而在Java.util.function.Consumer接口作为一个消费型接口，在接口中包含了一个抽象方法accept，消费一个指定泛型的数据。

2.过滤：filter

public class StreamForEach {
    public static void main(String[] args) {
        String[] array = {"肌肉猿","程序员非晚","程序员爱写Java"};
        Stream<String> stream = Stream.of(array);
        Stream<String> stringStream = stream.filter(s -> s.startsWith("程"));
    }
}
-----------------------------------------------------------------------------------------------------------------------
Stream<T> filter(Predicate<? super T> predicate);
-----------------------------------------------------------------------------------------------------------------------
@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * AND of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code false}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * OR of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code true}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T> the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *               which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

通过上面的代码观察我们可以得知，filter方法将一个流转化为另一个子集流，该接口接收一个Predicate接口参数，通过查看其内部我们不难发现该接口是一个函数式接口，因此可以使用Lambda表达式作为筛选条件。

3.映射：map

public class StreamMap {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("2023","02","14");
        Stream<Integer> result = original.map(s -> Integer.parseInt(s));
    }
}
-------------------------------------------------------------------------------------------------------------------
 <R> Stream<R> map(Function<? super T, ? extends R> mapper);
 --------------------------------------------------------------------------------------------------------------------
 @FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param <T> the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

通过上述代码观察，我们可以通过map映射（就是描述一种将T类型数据转化为R类型数据的操作）的方式将一个流中的元素映射到另一个流中，本质是通过接口中的Function函数，将当前流中的T类型数据转化为R类型数据。函数的内部又刚好是一个函数式接口。

4.取用前几个：limit

public class StreamLimit {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.of("肌肉猿", "程序员非晚", "爱Java爱分享","肌肉猿", "程序员非晚", "爱Java爱分享");
        Stream<String> stream = stringStream.limit(2);
        System.out.println(stream.count());//2
    }
}
-----------------------------------------------------------------------------------------------------------------------
  Stream<T> limit(long maxSize);

5.跳过前几个：skip

public class StreamSkip {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.of("肌肉猿", "程序员非晚", "爱Java爱分享","肌肉猿", "程序员非晚", "爱Java爱分享");
        Stream<String> stream = stringStream.skip(2);
        System.out.println(stream.count());//4
    }
}
-----------------------------------------------------------------------------------------------------------------------
Stream<T> skip(long n);

6.组合：concat

public class StreamConcat {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("肌肉猿");
        Stream<String> stream1 = Stream.of("程序员非晚");
        Stream<String> result = Stream.concat(stream, stream1);
    }
}
-----------------------------------------------------------------------------------------------------------------------
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));
    }

将两个流合并为一个流，注意本方法和string中的concat方法不同

附上String中的concat源码

public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

Stream流

前言

一、创建Stream流的三大基本步骤？

二、获取流的方式

1.根据Collection获取流

2.根据Map获取流

3.根据数组获取流

三、常用方法列举

1.逐一处理：forEach

2.过滤：filter

3.映射：map

4.取用前几个：limit

5.跳过前几个：skip

6.组合：concat

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Stream流

前言

一、创建Stream流的三大基本步骤？

二、获取流的方式

1.根据Collection获取流

2.根据Map获取流

3.根据数组获取流

三、常用方法列举

1.逐一处理：forEach

2.过滤：filter

3.映射：map

4.取用前几个：limit

5.跳过前几个：skip

6.组合：concat

热门文章

最新文章

相关电子书