Java8 Stream

🍓介绍

Java8中有两大最为重要的改变。第一个是 Lambda 表达式; 另外一个则是 Stream API(java.util.stream.*)。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用 Stream API 对集合数据进行操作，就类似于使用 SQL执行的数据库查询。也可以使用Stream API来并行执行操作简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

流(Stream)到底是什么呢?
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是致据, 而 Stream 讲的是让算”

注意：
Stream 自己不会存储元素。
Stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream。
Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

🍓生成 Stream

1/4 Collection体系集合

使用默认方法 stream() 生成流， default Stream<E> stream()

List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();

Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();

2/4 Map体系集合

把Map转成Set集合，间接的生成流

Map<String,Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

3/4 数组

通过Arrays中的静态方法stream生成流

String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Arrays.stream(strArray);

4/4 同种数据类型的多个数据

通过Stream接口的静态方法of(T… values)生成流

Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);

🍓Stream 流的中间操作

筛选与切片

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理,称为“惰性求值”。

filter：接收Lambda，从流中筛选出满足条件的元素。

过滤数据

// 留下满足条件的
Stream<T> filter(Predicate predicate)


Stream<T> stream = list.stream().filter(s -> s.startsWith("张"));

跳过（不要前几个）

Stream<T> skip(long n)

Stream<String> s2 = list.stream().skip(2);

截取（只取前几个）

Stream<T> limit(long maxSize)

Stream<T> stream = list.stream().limit(3);

实现分页

Integer currentPage = 3;
Integer pageSize = 10;
List<Integer> collect = list.stream().skip( (currentPage - 1) * pageSize ).limit(pageSize).collect(Collectors.toList());

合并

static Stream concat(Stream a, Stream b)

Stream.concat(s1,s2);

去重

筛选，通过流所生成元素的hashcode（）和equals（）去除重复元素，要想实现成功，必须实体类实现重写这两个方法！
Stream distinct()

list.stream().distinct();

🍓Stream流终结操作方法

对此流的每个元素执行操作

void forEach(Consumer action)

list.stream().forEach(System.out::println);

返回此流中的元素数

long count()

long count = list.stream().count();
System.out.println(count);

🍓Stream流的收集操作

List<String> names = listStream.collect(Collectors.toList());

Set<Integer> set = stream.collect(Collectors.toSet());

Map<Integer, String> map = stream.collect(Collectors.toMap(s -> s, s -> 2 * s + ""));

🍓求和

如果是 double 类型注意会遇到精度问题。so 不建议 double 类型的用这个方法。

long sum = list.stream().mapToLong(e -> e /** 可以指定具体字段 */).sum();

List<Project> list = projectService.list(queryWrapper);
//  总投资数
Long totalInvestment = list.stream().mapToLong(Project::getTotalInvestment).sum();

🍓实操

将集合中的某一列拿出来组合成新的集合

List<Integer> idList 
    = userList.stream().map(OrderUser::getPlatformUserId)
    .collect(Collectors.toList());

List 转 Set

Set<Integer> idSet = resourceObjectIdList.stream().collect(Collectors.toSet());

映射

map：接收Lambda , 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

List<Integer> list = Arrays.asList(13, 23, 99, 1889, 87, 1000, 88, 2, 99);

List<Integer> collect = list.stream().map(i -> i + 1).collect(Collectors.toList());
//  [14, 24, 100, 1890, 88, 1001, 89, 3, 100]

集合复制

List<CompanyChecks> checksList = //;
List<CompanyChecksNameVO> checksNameVOList = checksList.stream()
        .map(p -> {
            CompanyChecksNameVO vo = new CompanyChecksNameVO();
            BeanUtils.copyProperties(p, vo);
            return vo;
}).collect(Collectors.toList());

排序

public void test(){
    //自然排序
    List<String> list = Arrays.asList("aaa", "eee", "ddd", "bbb");
    list.stream().sorted().forEach(System.out::println);

    //定制排序
    List<Person> list1 = Arrays.asList(
            new Person("张三", 18, 2000.0),
            new Person("李四", 18, 5000.0),
            new Person("王五", 45, 8700.0),
            new Person("赵六", 42, 4200.0),
            new Person("陈七", 56, 13100.0)
    );
    list1.stream().sorted((p1,p2) -> {
        if (p1.getAge().equals(p2.getAge())){
            return p1.getSale().compareTo(p2.getSale());
        }else {
            return p1.getAge().compareTo(p2.getAge());
        }
    }).forEach(System.out::println);
}

List<Integer> list = Arrays.asList(13, 23, 99, 1889, 87, 1000, 88, 2, 99);
// 默认 顺序
List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
//  [2, 13, 23, 87, 88, 99, 99, 1000, 1889]

//  定制排序：倒序
List<Integer> collect = list.stream().sorted((v1, v2) -> v2 - v1).collect(Collectors.toList());
//  [1889, 1000, 99, 99, 88, 87, 23, 13, 2]

根据特定字段排序

正序

records = records.stream()
.sorted(Comparator.comparing(StudyReview::getReviewDate))
.collect(Collectors.toList());

倒序

records = records.stream()
.sorted(Comparator.comparing(StudyReview::getReviewDate).reversed())
.collect(Collectors.toList());

多个字段排序

list.stream().sorted(Comparator.comparing(User::getAge)
                        .thenComparing(User::getId)
                        .reversed())
                .forEach(System.out::println);