JDK 新特性——Stream 代码简洁之道，spring 视频教程在线观看

static void gen3(){

Stream<Integer> generate = Stream.generate(() -> 1);//使用 Stream 中的静态方法：generate()

//limit 返回由该流的元素组成的流，截断长度不能超过 maxSize

generate.limit(10).forEach(System.out::println);//打印输出(打印 10 个 1)

}

4.4 通过 Stream.iterate 方法来创建

//使用 iterator

static void gen4() {

Stream<Integer> iterate = Stream.iterate(1, x -> x + 1);//使用 Stream 中的静态方法：iterate()

iterate.limit(10).forEach(System.out::println);//打印输出(1,2,3,4,5,6,7,8,9,10)

}

4.4 其他 Api 创建

//其他方式

static void gen5(){

String str = "abcdefg";

IntStream stream =str.chars();//获取 str 字节码

stream.forEach(System.out::println);//打印输出(97,98,99,100,101,102,103)

}

五、Stream 的常用 API

5.1 中间操作

1. filter： 过滤流中的某些元素

//中间操作:如果调用方法之后返回的结果是 Stream 对象就意味着是一个中间操作

Arrays.asList(1,2,3,4,5).stream()//获取顺序流

.filter((x)->x%2==0) // 2 4

.forEach(System.out::println);

//求出结果集中所有偶数的和

int count = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9).stream()//获取顺序流

.filter(x -> x % 2 == 0).// 2 4 6 8

mapToInt(x->x).sum();//求和

System.out.println(count); //打印输出 20

2. distinct： 通过流中元素的 hashCode() 和 equals() 去除重复元素

Arrays.asList(1,2,3,3,3,4,5,2).stream()//获取顺序流

.distinct()//去重

.forEach(System.out::println);// 打印输出(1,2,3,4,5)

System.out.println("去重：---------------");

Arrays.asList(1,2,3,3,3,4,5,2).stream()//获取顺序流

.collect(Collectors.toSet())//Set()去重

.forEach(System.out::println);// 打印输出(1,2,3,4,5)

3. 排序

sorted()：返回由此流的元素组成的流，根据自然顺序排序。

sorted(Comparator com)：返回由该流的元素组成的流，根据提供的 Comparator 进行排序。

//获取最大值和最小值但是不使用 min 和 max 方法

List<Integer> list = Arrays.asList(1,2, 3,4, 5, 6);

Optional<Integer> min = list.stream().sorted().findFirst();//自然排序 根据数字从小到大排列

System.out.println(min.get());//打印输出（1）

Optional<Integer> max2 = list.stream().sorted((a, b) -> b - a).findFirst();//定时排序 根据最大数进行排序

System.out.println(max2.get());//打印输出（6）

//按照大小(a-z)排序

Arrays.asList("java","c#","python","scala").stream().sorted().forEach(System.out::println);

//按照长度排序

Arrays.asList("java","c#","python","scala").stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);

4. 截取

limit(n)：返回由此流的元素组成的流，截短长度不能超过 n

skip(n)：在丢弃流的第 n 元素后，配合 limit(n)可实现分页

//打印 20-30 这样的集合数据

Stream.iterate(1,x->x+1).limit(50)// limit 50 总共到 50

.skip(20)// 跳过前 20

.limit(10) // 打印 10 个

.forEach(System.out::println);//打印输出(21,22,23,24,25,26,27,28,29,30)

5. 转换

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

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

List<String> list = Arrays.asList("a,b,c", "1,2,3");

//将每个元素转成一个新的且不带逗号的元素

Stream<String> s1 = list.stream().map(s -> s.replaceAll(",", ""));

s1.forEach(System.out::println); // abc 123

Stream<String> s3 = list.stream().flatMap(s -> {

//将每个元素转换成一个 stream

String[] split = s.split(",");

Stream<String> s2 = Arrays.stream(split);

return s2;

});

s3.forEach(System.out::println); // a b c 1 2 3

6. 消费

peek：如同于 map，能得到流中的每一个元素。但 map 接收的是一个 Function 表达式，有返回值；而 peek 接收的是 Consumer 表达式，没有返回值。

//将 str 中的每一个数值都打印出来，同时算出最终的求和结果

String str ="11,22,33,44,55";

System.out.println(Stream.of(str.split(",")).peek(System.out::println).mapToInt(Integer::valueOf).sum());//11 22 33 44 55 165

5.2 终止操作

1. 循环：forEach

Users 类：

import java.util.Date;

/**

• @program: lambda

• @ClassName Users

• @description:

• @author: muxiaonong

• @create: 2020-10-24 11:00

• @Version 1.0

**/

public class Users {

private String name;

public Users() {}

/**

• @param name

*/

public Users(String name) {

this.name = name;

}

/**

• @param name

• @return

*/

public static Users build(String name){

Users u = new Users();

u.setName(name);

return u;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "name='" + name + ''';

}

}

//创建一组自定义对象

String str2 = "java,scala,python";

Stream.of(str2.split(",")).map(x->new Users(x)).forEach(System.out::println);//打印输出（name='java' name='scala' name='python'）

Stream.of(str2.split(",")).map(Users::new).forEach(System.out::println);//打印输出（name='java' name='scala' name='python'）

Stream.of(str2.split(",")).map(x->Users.build(x)).forEach(System.out::println);//打印输出（name='java' name='scala' name='python'）

Stream.of(str2.split(",")).map(Users::build).forEach(System.out::println);//打印输出（name='java' name='scala' name='python'）

2. 计算：min、max、count、sum

min：返回流中元素最小值

max：返回流中元素最大值

count：返回流中元素的总个数

sum：求和

//求集合中的最大值

List<Integer> list = Arrays.asList(1,2, 3,4, 5, 6);

Optional<Integer> max = list.stream().max((a, b) -> a - b);

System.out.println(max.get()); // 6

//求集合的最小值

System.out.println(list.stream().min((a, b) -> a-b).get()); // 1

//求集合的总个数

System.out.println(list.stream().count());//6

//求和

String str ="11,22,33,44,55";

System.out.println(Stream.of(str.split(",")).mapToInt(x -> Integer.valueOf(x)).sum());

System.out.println(Stream.of(str.split(",")).mapToI

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开：qq.cn.hn/FTe 免费领取

nt(Integer::valueOf).sum());

System.out.println(Stream.of(str.split(",")).map(x -> Integer.valueOf(x)).mapToInt(x -> x).sum());

System.out.println(Stream.of(str.split(",")).map(Integer::valueOf).mapToInt(x -> x).sum());

3. 匹配：anyMatch、 allMatch、 noneMatch、 findFirst、 findAny

anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回 true，否则返回 false

allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回 true，否则返回 false

noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回 true，否则返回 false

findFirst：返回流中第一个元素

findAny：返回流中的任意元素

List<Integer> list = Arrays.asList(1,2, 3,4, 5, 6);

System.out.println(list.stream().allMatch(x -> x>=0)); //如果集合中的元素大于等于 0 返回 true

System.out.println(list.stream().noneMatch(x -> x > 5));//如果集合中的元素有大于 5 的元素。返回 false

System.out.println(list.stream().anyMatch(x -> x > 4));//如果集合中有大于四 4 的元素，返回 true

//取第一个偶数

Optional<Integer> first = list.stream().filter(x -> x % 10 == 6).findFirst();

System.out.println(first.get());// 6

//任意取一个偶数

Optional<Integer> any = list.stream().filter(x -> x % 2 == 0).findAny();

System.out.println(any.get());// 2

4.收集器：toArray、collect

collect：接收一个 Collector 实例，将流中元素收集成另外一个数据结构

Collector<T, A, R>是一个接口，有以下 5 个抽象方法：

1. Supplier<A> supplier();创建一个结果容器 A

2. BiConsumer<A, T> accumulator();：消费型接口，第一个参数为容器 A，第二个参数为流中元素 T。

3. BinaryOperator<A> combiner();函数接口，该参数的作用跟上一个方法(reduce)中的 combiner 参数一样，将并行流中各个子进程的运行结果(accumulator 函数操作后的容器 A)进行合并。

4. Function<A, R> finisher();函数式接口，参数为：容器 A，返回类型为：collect 方法最终想要的结果 R。

5. Set<Characteristics> characteristics();返回一个不可变的 Set 集合，用来表明该 Collector 的特征

/**

• @program: lambda

• @ClassName Customer

• @description:

• @author: muxiaonong

• @create: 2020-10-24 11:36

• @Version 1.0

**/

public class Customer {

private String name;

private Integer age;

...getset 忽略

}

public static void main(String[] args) {

Customer c1 = new Customer("张三",10);

Customer c2 = new Customer("李四",20);

Customer c3 = new Customer("王五",10);

List<Customer> list = Arrays.asList(c1,c2,c3);

//转成 list

List<Integer> ageList = list.stream().map(Customer::getAge).collect(Collectors.toList());

System.out.println("ageList："+ageList);//ageList：[10, 20, 10]

//转成 set

Set<Integer> ageSet = list.stream().map(Customer::getAge).collect(Collectors.toSet());

System.out.println("ageSet："+ageSet);//ageSet：[20, 10]

//转成 map,注:key 不能相同，否则报错

Map<String, Integer> CustomerMap = list.stream().collect(Collectors.toMap(Customer::getName, Customer::getAge));

System.out.println("CustomerMap："+CustomerMap);//CustomerMap：{李四=20, 张三=10, 王五=10}

//字符串分隔符连接

String joinName = list.stream().map(Customer::getName).collect(Collectors.joining(",", "(", ")"));

System.out.println("joinName："+joinName);//joinName：(张三,李四,王五)

//聚合操作

//1.学生总数

Long count = list.stream().collect(Collectors.counting());

System.out.println("count："+count);//count：3

//2.最大年龄 (最小的 minBy 同理)

Integer maxAge = list.stream().map(Customer::getAge).collect(Collectors.maxBy(Integer::compare)).get();

System.out.println("maxAge："+maxAge);//maxAge：20

//3.所有人的年龄

Integer sumAge = list.stream().collect(Collectors.summingInt(Customer::getAge));

System.out.println("sumAge："+sumAge);//sumAge：40

//4.平均年龄

Double averageAge = list.stream().collect(Collectors.averagingDouble(Customer::getAge));

System.out.println("averageAge："+averageAge);//averageAge：13.333333333333334

//分组

Map<Integer, List<Customer>> ageMap = list.stream().collect(Collectors.groupingBy(Customer::getAge));

System.out.println("ageMap："+ageMap);//ageMap：{20=[com.mashibing.stream.Customer@20ad9418], 10=[com.mashibing.stream.Customer@31cefde0, com.mashibing.stream.Customer@439f5b3d]}

//分区

//分成两部分，一部分大于 10 岁，一部分小于等于 10 岁

Map<Boolean, List<Customer>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));

System.out.println("partMap："+partMap);

//规约

Integer allAge = list.stream().map(Customer::getAge).collect(Collectors.reducing(Integer::sum)).get();

System.out.println("allAge："+allAge);//allAge：40

}