Stream流简单使用（一）

1. Stream流是什么？

支持顺序和并行聚合的元素序列操作。

Person

package com.xtsheng.lambdastudy;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Person
 *
 * @author zouxiaoao
 * @date 2021年10⽉21⽇ 9:42
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    private String userName;

    private String niceName;

    private String programmer;

    private String sex;

    private Integer age;

    private Integer sale;

}

Main

package com.xtsheng.lambdastudy;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;

/**
 * LambdaTest
 *
 * @author zouxiaoao
 * @date 2021年10⽉21⽇ 9:16
 */
public class LambdaTest {

    static List<Person> personList = new ArrayList<Person>() {
        {
            add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
            add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
            add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
            add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
            add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
            add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
            add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));
            add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
            add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));
            add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));
        }
    };

    public static void main(String[] args) {
        // 测试方法
        filterTest();

    }
}

1.1 filter 匹配

返回由匹配流中的元素组成的流给定谓词。

filter 源码

    @Override
    @SuppressWarnings("unchecked")
    public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
        Objects.requireNonNull(mapper);
        return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
                return new Sink.ChainedReference<P_OUT, R>(sink) {
                    @Override
                    public void accept(P_OUT u) {
                        downstream.accept(mapper.apply(u));
                    }
                };
            }
        };
    }

    /**
     * 根据某个条件进行过滤，取出对象中想要的信息。
     * @author zouxiaoao
     * @date 2021/10/21 10:31
     */
    static void filterTest() {
        List<Person> collect = personList.stream()
                .filter(person -> person.getAge() > 40)
                .collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

1.2 map

返回一个由应用给定结果组成的流函数指向该流的元素

map 源码

    @Override
    @SuppressWarnings("unchecked")
    public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
        Objects.requireNonNull(mapper);
        return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
                return new Sink.ChainedReference<P_OUT, R>(sink) {
                    @Override
                    public void accept(P_OUT u) {
                        downstream.accept(mapper.apply(u));
                    }
                };
            }
        };
    }

    /**
     * 从list中取出对象中的某个属性
     * @author zouxiaoao
     * @date 2021/10/21 11:19 
     */
    static void mapTest(){
        List<String> personUserName = personList.stream()
                .map(person -> person.getUserName())
                .collect(Collectors.toList());
        personUserName.forEach(System.out::println);
    }

1.3 distinct

去掉重复对象

distinct 部分 源码

    @Override
    public final Stream<P_OUT> distinct() {
        return DistinctOps.makeRef(this);
    }

    /**
     * 去掉重复对象
     * @author zouxiaoao
     * @date 2021/10/21 13:41
     */
    static void distinctTest(){
        List<Person> distinctPerson = personList.stream()
                .distinct()
                .collect(Collectors.toList());
        distinctPerson.forEach(System.out::println);
    }

1.4 sorted

对集合中的对象进行排序

sorted 部分 源码

    @Override
    public final Stream<P_OUT> sorted(Comparator<? super P_OUT> comparator) {
        return SortedOps.makeRef(this, comparator);
    }

    /**
     * 对集合中的对象进行排序
     * @author zouxiaoao
     * @date 2021/10/21 13:55
     */
    static void sortedTest(){
        List<Person> sortedPerson = personList.stream()
                .sorted((p1, p2) -> (p1.getAge().compareTo(p2.getAge())))
                .collect(Collectors.toList());
        sortedPerson.forEach(System.out::println);
    }

1.5 peek

返回由该流的元素组成的流，并在从结果流中消费元素时对每个元素执行提供的操作。

peek 源码

    @Override
    public final Stream<P_OUT> peek(Consumer<? super P_OUT> action) {
        Objects.requireNonNull(action);
        return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                     0) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
                return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                    @Override
                    public void accept(P_OUT u) {
                        action.accept(u);
                        downstream.accept(u);
                    }
                };
            }
        };
    }

    /**
     *
     * @author zouxiaoao
     * @date 2021/10/21 14:11
     */
    static void peekTest(){
        List<Person> persons = personList.stream()
                .filter(p -> p.getAge() > 30)
                .peek(System.out::println)
                .collect(Collectors.toList());
        System.out.println("------------");
        persons.forEach(System.out::println);
    }

1.6 limit

返回由该流的元素组成的流，截断后的长度不超过maxSize。

limit 源码

    @Override
    public final Stream<P_OUT> limit(long maxSize) {
        if (maxSize < 0)
            throw new IllegalArgumentException(Long.toString(maxSize));
        return SliceOps.makeRef(this, 0, maxSize);
    }

    /**
     * 返回由该流的元素组成的流，截断后的长度不超过maxSize。
     * @author zouxiaoao
     * @date 2021/10/21 14:14
     */
    static void limitTest(){
        List<Person> persons = personList.stream()
                .limit(3)
                .collect(Collectors.toList());
        persons.forEach(p -> System.out.println(p));
    }

1.7 skip

在丢弃流的前n个元素后，返回由该流的剩余元素组成的流。

skip 源码

    @Override
    public final Stream<P_OUT> skip(long n) {
        if (n < 0)
            throw new IllegalArgumentException(Long.toString(n));
        if (n == 0)
            return this;
        else
            return SliceOps.makeRef(this, n, -1);
    }

    /**
     * 在丢弃流的前n个元素后，返回由该流的剩余元素组成的流。
     * @author zouxiaoao
     * @date 2021/10/21 14:18
     */
    static void skipTest(){
        List<Person> persons = personList.stream()
                .skip(2)
                .collect(Collectors.toList());
        persons.forEach(System.out::println);
    }

1.8 forEach

对流中的每个元素执行操作。

forEach 源码

        @Override
        public void forEach(Consumer<? super E_OUT> action) {
            if (!isParallel()) {
                sourceStageSpliterator().forEachRemaining(action);
            }
            else {
                super.forEach(action);
            }
        }

    /**
     * 对流中的每个元素执行操作。
     * @author zouxiaoao
     * @date 2021/10/21 14:22 
     */
    static void foreachTest(){
        personList.stream()
                .forEach(p -> System.out.println(p));
    }

1.9 toArray

toArray 部分 源码

    @Override
    public final Object[] toArray() {
        return toArray(Object[]::new);
    }

    /**
     * 返回包含此流元素的数组。
     * @author zouxiaoao
     * @date 2021/10/21 14:26
     */
    static void toArrayTest(){
        Object[] objects = personList.stream()
                .toArray();
        Arrays.stream(objects).forEach(System.out::println);

    }