---

介绍

Java8中有两大最为重要的改变。第一个是 Lambda 表达式; 另外一个则是 Stream API(java.util.stream.*)。
Stream是 Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用 Stream API 对集合数据进行操作，就类似于使用 SQL执行的数据库查询。也可以使用Stream API来并行执行操作简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

流(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 流的中间操作

筛选与切片

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