java 8 的流库
1.从迭代到流的操作
流 你可以理解成比集合更高级的一个api，提供了很多有用的方法…
1. Stream的两种 stream() | parallelStream()
List<String> strList = Arrays.asList("a", "b", "c", "d", "e");
strList.stream().forEach(System.out::print);
strList.parallelStream().forEach(System.out::print);
//打印结果
abcde
----------
cdeab
注：stream() | parallelStream()区别
stream()是按照集合顺序，parallelStream()是并行处理，所以当你对流的操作不需要顺序这个需求时，例如：求和， 求平均值，过滤，最大值等，优先考虑 parallelStream
2. foreach()
List<String> strList = Arrays.asList("a", "b", "c", "d", "e");
strList.stream().forEach(System.out::print);
//打印结果
abcde
注：foreach()
和List的foreach差不多 ，遍历出所有的元素
3. count()
List<String> strList = Arrays.asList("a", "b", "c", "d", "e");
long count = strList.stream().count();
//打印结果
5
注：count()
和List的size()差不多 ，产生流中元素的数量，是个终止操作（可以理解为返回类型不是Stream）
2.流的创建
1. Stream.of(T… values)
Integer[] ints = {1, 2, 3, 4, 5};
Stream<Integer> integerStream1 = Stream.of(ints);
integerStream1.forEach(System.out::print);
System.out.println();
System.out.println("----------");
Stream<Integer> integerStream2 = Stream.of(1, 2, 3, 4, 5);
integerStream2.forEach(System.out::print);
System.out.println();
System.out.println("----------");
Stream<Integer> integerStream3 = Arrays.stream(ints, 1, 3);
integerStream3.forEach(System.out::print);
//打印结果
12345
----------
12345
----------
23
注： 流的创建， 在操作力已经有collection里的stream()方法，这个静态方法可变长参数，
对于数组 还可以截取
2. Stream.empty()
**注：** 创建了一个不含任何元素的流， 相当于new了一个集合一样，里面啥都没有
3. Stream.generate()
Stream<String> s = Stream.generate(() -> "a").limit(5);
//会生成 aaaaaaaaaaaa.........无线下去
注： generate() 传参是一个提供商（Supplier）然后生成一个无线元素的流
4. Stream.iterate()
Stream<Integer> iterate = Stream.iterate(5, n -> n < 10, n -> n + 1);
iterate.forEach(System.out::print);
//打印结果
56789
注： 相对于generate(), 你给定一个的参数 然后后续元素是基于这个参数生成， 并且可以加一个限定条件
参数一：给定单数 (种子)
参数二：后续生成元素必须符合的条件，断言，（参数二可不写）
参数三：对于给定参数进行操作生成新的元素
5. Stream.ofNullable(T)
List<String> strList = Arrays.asList("a", "b", "c", "d", "e");
Stream<List<String>> strStream = Stream.ofNullable(strList);
strStream.forEach(System.out::print);
//打印结果
[a, b, c, d, e]
注： ofNullable(T) 相对于它可以在T对象为null时返回 返回一个空的流，如果不为null，返回质保函一个元素（该元素就是T ）的流，这个流的元素不是 5 个, 而是一整个List, 所以通常与flatMap相结合
3.filter、map和flatMap方法
概念： 流的转换会产生一个新的流，它的元素派生自另一个流的元素。
1. filter()
Integer[] ints = {1, 2, 3, 4, 5};
Stream<Integer> ints1 = Stream.of(ints);
ints1.filter(integer -> integer > 2).forEach(System.out::print);
//打印结果
345
注： filter() 里的参数是断言， 你提供一个条件， 之后会返回一个满足该条件元素的流
2. map()
Integer[] ints = {1, 2, 3, 4, 5};
Stream<Integer> ints1 = Stream.of(ints);
ints1.map(integer -> integer + 2).forEach(System.out::print);
//打印结果
34567
注： map() 是按照某种方式转化流种的值使用map()时，会有一个函数应用到每个元素上，并且将处理完的结果的所有元素重写放到一个流中
用于对象时有个疑问
//假如有个集合List<Banner> banners 里面有好多元素
//错误写法
//有时会认为 把banner这个对象set一个值之后放到新的流中，但是是错的,因为banner.setStatus()返回值是void
Stream<Banner> collect = banners.stream()
.map(banner -> {
banner.setStatus(BannerVO.STATUS_2);
});
//正确写法（为了好熟悉逻辑这样写，有好多种方法）
Stream<Banner> collect = banners.stream()
.map(banner -> {
Banner banner1 = new Banner();
banner1.setId(banner.getId());
banner1.setStatus(BannerVO.STATUS_2);
return banner1;
}).collect(Collectors.toList());
3. flatMap()
List<List<Integer>> list = new ArrayList<>();
List<Integer> list1 = Arrays.asList(1,2,3,4,5);
List<Integer> list2 = Arrays.asList(6,7,8,9,0);
list.add(list1);
list.add(list2);
Stream<Integer> stream = list.stream().flatMap(integers -> integers.stream().limit(2));
stream.forEach(System.out::println);
//打印结果
1
2
6
7
注： 与map()不同的是 他会对元素再次降维处理，如果上面是map处理的话会打印出[1,2] [6,7]
这也是所谓的扁平化（最好自己写个简单的例子感受一下，并且与map对比一下！！）
4.抽取子流和组合流
1. limit()
List<String> strList = Arrays.asList("a", "b", "c", "d", "e");
strList.stream().limit(2).forEach(System.out::println);
//打印结果
a
b
注： limit(long size) 就是把你的当前元素的个数保留多少个（从前往后）比如limit(2)那么就会保留前两个元素， 如果流中的元素不够两个，那么保留当前元素
2. skip()
List<String> strList = Arrays.asList("a", "b", "c", "d", "e");
strList.stream().skip(2).forEach(System.out::println);
//打印结果
c
d
e
**注：**skip() 与 limit()相反 它是跳过多少元素，保留之后的元素
3. takeWhile()
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 0, 1, 2);
integerStream.takeWhile(integer -> integer < 3).forEach(System.out::println);
//打印结果
1
2
注: 参数是一个断言，它比较特殊， 从前往后执行，如果循环执行到当前元素不符合断言条件，那么保留之前的元素， 后面的元素不管符不符合都被舍弃
4. dropWhile()
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 0, 1, 2);
integerStream.dropWhile(integer -> integer < 4).forEach(System.out::println);
//打印结果
4
5
0
1
2
注： 这和takeWhile()完全相反 它是从前往后比较时，如果元素符合条件，则把元素丢弃，直到不符合的元素时，保留不符合元素以及之后的所有元素
5. concat()
Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> integerStream2 = Stream.of(6, 7, 8, 9, 10);
Stream.concat(integerStream1, integerStream2).forEach(System.out::println);
//打印结果
1
2
3
4
5
6
7
8
9
10
注： 将两个流组合在一起 和List中的addAll类似， 不过它是静态方法
5.其他流的转换
1. distinct()
Stream<Integer> integerStream1 = Stream.of(1, 2, 2, 1, 1);
integerStream1.distinct().forEach(System.out::println);
//打印结果
1
2
**注：**和它的名称一样， 去重， 去除重复元素，顺序不变
2. sorted()
//按照字符串的长度进行排序
Stream<String> integerStream1 = Stream.of("a", "aaa", "aaaaaaa", "aaaa", "aa");
integerStream1.sorted(Comparator.comparing(String::length)).forEach(System.out::println);
//打印结果
a
aa
aaa
aaaa
aaaaaaa
注： 其他比较还有Comparator.comparingInt()，Comparator.comparingDouble()，Comparator.comparingLong()都可以进行比较
3. peek()
属于中间操作，它的作用主要用于调试，不介绍
6.简单约减（终结操作）
1. max()
Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4, 5);
Integer integer = integerStream1.max(Integer::compareTo).get();
System.out.println(integer);
//打印结果
5
注： max()本身返回的是Optional类型，它会返回一个按照比较方式最大的元素
2. min()
与max()同理
3. findFirst()
Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4, 5, 4, 3, 2);
Optional<Integer> first = integerStream1.findFirst();
System.out.println(first.get());
注： 返回的是返回的是Optional类型 他会寻找第一个元素并返回 通常与limit或者filter使用
4. findAny()
同上述 它是找所有 主要是为了返回Optional类型
注： 和findFirst()同样 如果上述为空 则返回空的Optional对象 这也是伟大之处 避免了空指针
5. anyMatch()
Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4, 5, 4, 3, 2);
boolean b = integerStream1.anyMatch(integer -> integer > 10);
System.out.println(b);
//打印结果
false
注： 是否存在匹配 也就是只要有一个元素匹配上了，就返回true,否则false
6. allMatch()
所有元素都匹配返回true
7. noneMatch()
所有元素都不匹配返回true
7.Optional类型
1.获取Optional值
1.orElse()
Optional<Integer> optional = Optional.empty();
Integer integer = optional.orElse(5);
System.out.println(integer);
//打印结果
5
注： 当optional为空时 会返回你给的值, 如果不为空，则返回optional包装的值
2.orElseGet（）
Optional<Integer> optional = Optional.empty();
Integer integer = optional.orElseGet(this::supplier);
System.out.println(integer);
private Integer supplier() {
return 20;
}
//打印结果
20
注： 与orElse()相比较当optional为空时 会返回你产生调用的结果, 如果不为空，则返回optional包装的值
3.orElseThrow()
与上述一样， 只是返回一个异常
2.消费Optional值
1.ifPresent()
List<Integer> list = new ArrayList<>();
Optional<Integer> optional = Optional.of(1);
optional.ifPresent(list::add);
for (Integer integer : list) {
System.out.println(integer);
}
//打印结果
1
注： 如果该值存在的情况下执行具体的操作
2.ifPresentOrElse()
List<Integer> list = new ArrayList<>();
Optional<Integer> optional = Optional.empty();
optional.ifPresentOrElse(list::add, () ->System.out.println("sssssss"));
for (Integer integer : list) {
System.out.println(integer);
}
//打印结果
sssssss
注： 如果该值存在的情况下执行具体的操作, 否则 执行另一种操作
3.管道化Optional值
1.map()
Optional<Integer> optional = Optional.of(1);
Optional<Integer> result = optional.map(integer -> integer + 1);
System.out.println(result.get());
//打印结果
2
注： 对Optional包装的对象进行操作并返回，和Stream的map类似，只不过Optional的长度是1或0
且如果为空，什么也不发生，不用担心null 这也是Optional的优势之一
2.filter()
且如果为空，什么也不发生，不用担心null 这也是Optional的优势之一
和Stream的map类似，只不过Optional的长度是1或0
且如果为空，什么也不发生，
3.or()
Optional<List<Integer>> optional = Optional.empty();
Optional<List<Integer>> result = optional.or(this::supplier);
result.get().forEach(System.out::println);
private Optional<List<Integer>> supplier() {
return Optional.of(List.of(1,2,3));
}
//打印结果
1
2
3
注： 如果Optional是空 那么会提供一个Optional
4.注意事项
取值时常用的是get() 但是get方法当Optional为空时，会抛出异常，相当于orElseThrow()抛出指定的NoSuchElementException异常，所以在用Optional时可以用isPresent()先去判断，当然，如果在之前先判断好value的值不为null更方便
1.get()
获取被包装的值，上面的map()方法的例子已经用到
2.isPresent()
Optional<List<Integer>> optional1 = Optional.empty();
System.out.println(optional1.isPresent());
Optional<List<Integer>> optional2 = Optional.of(List.of(1,2,3));
System.out.println(optional2.isPresent());
//打印结果
false
true
注： 如果Optional是空 返回 false, 反之，true， 在我写这个文章时用的是jdk11，出现了isEmpty()效果是一样的
5，创建Optional值
有三种方式
1.of()
2.ofNullable()
3.empty()
注： 第一种和第二种时产生一个给定值的Optional，如果value为null,第一个会抛异常，第二个会产生一个空的Optional
第三种是产生一个空的Optional
6.用flatMap构建Optional值的函数
1.flatMap()
Optional<Double> optional = Optional.of(4d);
//比较map与flatMap的区别
Optional<Double> optional1 = optional.flatMap(this::squ);
Optional<Optional<Double>> optional2 = optional.map(this::squ);
System.out.println(optional1.get());
private Optional<Double> squ(double x) {
return x < 0 ? Optional.empty() : Optional.of(Math.sqrt(x));
}
//打印结果
2
注： map与flatMap的区别：
map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。
但flatMap方法中的lambda表达式返回值必须是Optionl实例。
也就是说 map在执行到把每个结果包装成一个Optional
flatMap把所有结果平铺之后包装成一个Optional
flatMap主要是你可以封装一个方法 然后调用时候方便
7.将Optional转换为流
1.Stream()
Optional<List<Integer>> optional = Optional.of(List.of(1,2,3,4));
Stream<List<Integer>> stream = optional.stream();
Stream<Integer> stream1 = stream.flatMap(integers -> integers.stream().map(integer -> integer + 1));
stream1.forEach(System.out::println);
//打印结果
2
3
4
5
注： 上述例子可以说明其实结合flatMap时会非常有用 因为Optional的长度是0/1,那么对于集合或者对象时候用flatMap扁平化处理之后得到更多的元素
8.收集结果
1.iterator()
获得迭代器（可以用foreach代替）
2.foreach()/foreachOrdered()
循环获取每个元素，foreachOrdered()实在用并行流时可以让按照顺序输出元素，例子前面已经有很多
3.toArray()
List<Integer> list1 = Arrays.asList(1,2,3,4,5);
Integer[] integers = list1.stream().toArray(Integer[]::new);
注： 如果不传A[]::new时 将返回Object[]
4.collect(Collectors)
Stream<Integer> stream1 = Stream.of(1,2,3,4,5);
Stream<Integer> stream2 = Stream.of(1,2,3,4,5);
Stream<Integer> stream3 = Stream.of(1,2,3,4,5);
Stream<Integer> stream4 = Stream.of(1,2,3,4,5);
Stream<Integer> stream5 = Stream.of(1,2,3,4,5);
Stream<String> stream6 = Stream.of("1","2","3","4","5");
Stream<String> stream7 = Stream.of("1","2","3","4","5");
Stream<Integer> stream8 = Stream.of(1,2,3,4,5);
//把流中的元素收集到一个list中
List<Integer> collect1 = stream1.collect(Collectors.toList());
//把流中的元素收集到一个只可读的list中
List<Integer> collect2 = stream2.collect(Collectors.toUnmodifiableList());
//把流中的元素收集到一个set中
Set<Integer> collect3 = stream3.collect(Collectors.toSet());
//把流中的元素收集到一个只可读set中
Set<Integer> collect4 = stream4.collect(Collectors.toUnmodifiableSet());
//把流中的元素收集到一个指定类型的集合中
List<Integer> collect5 = stream5.collect(Collectors.toCollection(ArrayList::new));
//对于String类型的可以把元素按照指定的标识分隔开并扁平化成一个字符串
String collect6 = stream6.collect(Collectors.joining(","));
//对于String类型的可以把元素按照指定的标识分隔开并扁平化成一个字符串,并且有指定的前后缀，默认前后缀为空
String collect7 = stream7.collect(Collectors.joining(",", "", ""));
//产生（Int|Long|Double）SummaryStatistics对象的收集器，
//对应的有getCount():获取元素个数
//getSum():获取总和
//getAverage():获取元素的平均值
//getMax()/getMin()获取最大最小值
long count = stream8.collect(Collectors.summarizingInt(Integer::intValue)).getCount();
注： 上述是最基本的收集结果
9.收集到映射表中
1.Collectors.toMap()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab" + i);
} else if(i > 3 && i < 7) {
user.setAccount("cd" + i);
}else {
user.setAccount("ef" + i);
}
users.add(user);
}
Map<Integer, String> collect = users.stream()
.collect(Collectors.toMap(User::getId, User::getAccount));
collect.forEach((id, account) -> {
System.out.println("id=" + id + " ;account=" + account );
});
//打印结果
id=0 ;account=ab0
id=1 ;account=ab1
id=2 ;account=ab2
id=3 ;account=ef3
id=4 ;account=cd4
id=5 ;account=cd5
id=6 ;account=cd6
id=7 ;account=ef7
id=8 ;account=ef8
id=9 ;account=ef9
注： 1. 其实就是把对象收集程key,value形式，这个key value都是从每个元素中获得
如果value是当前的对象 那么 toMap(key, Function.identity())
2. 存在这种情况， key出现相同，此时会抛出异常
你可以通过第三个参数来解决，是取新值还是保留之前的值
collect(Collectors.toMap(User::getId, User::getAccount，(oldValue, newValue) -> newValue)) 即可
也存在第四个参数， 指定Map的类型
10.群组和分区
通过上述说的转化成Map, 这个是按照key相同的分成一组
1.Collectors.groupingBy()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<String, List<User>> collect = users.stream().collect(Collectors.groupingBy(User::getAccount, Collectors.toList()));
collect.forEach((account, userList) -> {
System.out.println("account=" + account);
userList.forEach(user -> System.out.println("id:" + user.getId() + ";account:" + user.getAccount()));
});
//打印结果
account=cd
id:4;account:cd
id:5;account:cd
id:6;account:cd
account=ef
id:3;account:ef
id:7;account:ef
id:8;account:ef
id:9;account:ef
account=ab
id:0;account:ab
id:1;account:ab
id:2;account:ab
注： 可以看到是按照给定的key把对象分组
2.Collectors.partitioningBy(）
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<Boolean, List<User>> collect = users.stream().collect(Collectors.partitioningBy(user -> user.getId() == 1));
collect.forEach((booleanValue, userList) -> {
System.out.println("booleanValue=" + booleanValue);
userList.forEach(user -> System.out.println("id:" + user.getId() + ";account:" + user.getAccount()));
});
//打印结果
booleanValue=false
id:0;account:ab
id:2;account:ab
id:3;account:ef
id:4;account:cd
id:5;account:cd
id:6;account:cd
id:7;account:ef
id:8;account:ef
id:9;account:ef
booleanValue=true
id:1;account:ab
注： 是按照给定条件分成 true和false两组，用于判断时特别方便，不用去循环了
11.下游收集器
就是对分组的结果 再进行处理 除了上面叙述的 Collectors.toList()等，还有以下收集
1. Collectors.counting()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<String, Long> collect = users.stream().collect(Collectors.groupingBy(User::getAccount, Collectors.counting()));
collect.forEach((account, count) -> {
System.out.println("account=" + account + "| count:" + count);
});
//打印结果
account=cd| count:3
account=ef| count:4
account=ab| count:3
注： 按照key分组完之后， 收集对应的个数
2. Collectors.summing()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<String, Integer> collect = users.stream().collect(Collectors.groupingBy(User::getAccount, Collectors.summingInt(User::getId)));
collect.forEach((account, count) -> {
System.out.println("account=" + account + "| count:" + count);
});
//打印结果
account=cd| count:15
account=ef| count:27
account=ab| count:3
注： 按照key分组完之后， 对收集的结果中的每个组中的id进行求和得出结果作为value值
3. Collectors.maxBy()/minBy()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<String, Optional<User>> collect = users.stream()
.collect(Collectors.groupingBy(User::getAccount, Collectors.maxBy(Comparator.comparingInt(User::getId))));
collect.forEach((account, optional) -> {
System.out.println("account=" + account + "| id:" + optional.get().getId() );
});
//打印结果
account=cd| id:6
account=ef| id:9
account=ab| id:2
注： 按照key分组完之后， 对收集的结果中的每个组找到id值最大的user对象并包装成Optional最为value值 如果存在并列相等的，则只会保留一个对象
4. Collectors.collectingAndThen()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(1);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<String, Integer> collect = users.stream()
.collect(Collectors.groupingBy(User::getAccount, Collectors.collectingAndThen(Collectors.toList(), List::size)));
collect.forEach((account, size) -> {
System.out.println("account=" + account + "| size:" +size );
});
//打印结果
account=cd| size:3
account=ef| size:4
account=ab| size:3
注： 按照key分组完之后， 对收集的结果中再进行一波操作，然后收集到一个集中
5. Collectors.mapping()
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i ++) {
User user = new User();
user.setId(i);
if(i < 3) {
user.setAccount("ab");
} else if(i > 3 && i < 7) {
user.setAccount("cd" );
}else {
user.setAccount("ef");
}
users.add(user);
}
Map<String, List<Integer>> collect = users.stream()
.collect(Collectors.groupingBy(User::getAccount, Collectors.mapping(Key::getId, Collectors.toList())));
collect.forEach((account, size) -> {
System.out.println("account=" + account + "| size:" +size );
});
//打印结果
account=cd| size:[4, 5, 6]
account=ef| size:[3, 7, 8, 9]
account=ab| size:[0, 1, 2]
注： 与collectingAndThen相反 按照key分组完之后， 对对每个元素进行操作，然后收集到一个集中
6. 其他
- Collectors.flatMapping()//如果收集的元素是流可以铺平
- Collectors.summarizingInt() summarizing系列 返回的是该系列对象
- filtering() 对于每个元素进行过滤，然后收集起来
和上述的例子相同，不一一展示！
12.约简操作
1.reduce()
Stream<Integer> stream1 = Stream.of(1,2,3,4,5);
Optional<Integer> reduce = stream1.reduce((a, b) -> a + b);
//Optional<Integer> reduce = stream1.reduce(Integer::sum);
System.out.println(reduce.get());
//打印结果
15
注： 简单的形式是接受一个二元函数，并从前两个元素开始持续应用它，得到结果
你也可以给一个初始的元素， 如果流为空，就返回这个元素，就不许需要处理Optional类了
reduce(0, (a, b) -> a + b)
也可以用三个的参数，一般用于处理某个对象属性时
Stream<Integer> stream1 = Stream.of(1,2,3,4,5);
Integer reduce = stream1.reduce(0, Integer::sum, Integer::sum);
System.out.println(reduce);
//打印结果
15
13.基本类型流
它是解决基本类型到包装基本类型对象的低效性，可以看成特殊的Stream，所有它的创建和Stream一样
其他的Api和Stream一样
1.IntStream
对于short,byte,char boolean int可以使用
1.range()/rangeClosed()
IntStream stream1 = IntStream.range(0,5);
stream1.forEach(System.out::println);
//打印结果
0
1
2
3
4
注： 相对于Stream里的generate和iterate方法 它是生成间隔为1的整数范围的元素
rangeClosed()是上线包括 [0,5]
range()是[0, 5)
2.boxed()
产生当前流中的元素的包装器对象流 IntStream -> Stream<Integer>
326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
