IntStream 是特殊的 Stream，但有一些操作符是 IntStream 独有的；话不多说，开始玩转 IntStream 吧。
1. 理论讲解
1.1 构造 IntStream
IntStream 这个接口里提供了如下方法：
1
| IntStream.generate() 产生一个无限流，这里需要传入一个 IntSupplier 函数式接口实例 。
|
1
| IntStream.range() 产生指定区间的有序 IntStream，这里需要传入一个区间（左闭右开），产生的元素不包含最后一个。
|
1
| IntStream.rangeClosed() 产生指定区间的有序 IntStream，与 IntStream.range() 不同的是，产生的元素包含最后一个，即左闭右闭。
|
1
| IntStream.of() 填充一个或多个 int 元素构造流。
|
1
| IntStream.empty() 产生一个空元素的流。
|
1
| IntStream.builder() 会产生一个 builder 用于构建 stream，通过 builder 的 add 方法添加元素，build 方法构造流。
|
1
| IntStream.iterate() 产生一个有序的无限流，需要传入初始值，对元素操作的函数。
|
1
| IntStream.concat() 将两个流合并成一个流。
|
1.2 操作 IntStream
1.2.1 过滤操作
1.2.2 转换操作
1
| map() 产生的仍然是 IntStream，可以对元素进行数学上的操作，加减乘除等等。
|
1
| mapToObj() 转成对象流，例如 String 等。
|
1
| mapToLong() 转成 long 类型流。
|
1
| mapToDouble() 转成 double 类型流。
|
1
| asLongStream() 快速转成 Long 类型的 Stream。
|
1
| asDoubleStream() 快速转成 Double 类型的 Stream。
|
1.2.3 拍扁操作
1.2.4 去重操作
1
| distinct() 元素去重，底层用的还是 equals。
|
1.2.5 排序操作
1.2.6 查看元素
1
| peek() 需传入一个 IntConsumer 实例。
|
1.2.7 限流操作
1.2.8 跳过操作
1.2.9 遍历操作
1
| forEach() 传入 IntConsumer 实例。
|
1
| forEachOrdered() 与 forEach 相比，对元素进行有序遍历。
|
1.2.10 数组操作
1.2.11 规约操作
1
| reduce() 将所有元素规约聚合成一个，需传入一个 IntBinaryOperator 实例，返回一个 optionalInt，结果不一定有值。
|
1
| reduce() 重载 reduce，需要传入初始值和 IntBinaryOperator 实例，最终的结果一定有值。
|
1.2.12 收集操作
1
| collect() 需要传入一个结果容器，元素累加器，组合器
|
1
| collect() 是重载方法，可以传入 Collectors 的实例。
|
1.2.13 数学操作
1
| sum() 求和操作，底层用 reduce 实现。
|
1
| max() 求最大值，底层用 reduce 实现。
|
1
| min() 求最小值，底层用 reduce 实现。
|
1
| summaryStatistics() 汇总统计，计算 sum、max、min、count、average。
|
1.2.14 匹配操作
1
| anyMatch() 任何一个元素符合条件，传入一个 IntPredicate 实例。
|
1.2.15 查询操作
1
| findFirst() 获取流中的第一个元素，可能没有。
|
1
| findAny() 随机获取流中的任意一个元素，可能没有。
|
1.2.16 装箱操作
2. 实践出真知
2.1 构造 IntStream
1）generate() 会产生一个无限的流，这里需要使用 limit 限制。
1
2
3
4
5
6
7
| @Test
public void testGenerate() {
int sum = IntStream.generate(() -> 2).limit(10).sum();
System.out.println(sum);
}
|
2）range() 产生一个区间（左闭右开）内的有序流。
1
2
3
4
5
6
| @Test
public void testRange() {
int sum = IntStream.range(1, 10).sum();
System.out.println(sum);
}
|
3）rangeClosed() 产生一个区间（左闭右闭）内的有序流，包含区间最后一个元素。
1
2
3
4
5
| @Test
public void testRangeClosed() {
int sum = IntStream.rangeClosed(0, 10).sum();
System.out.println(sum);
}
|
4）of() 快速使用值创建流。
1
2
3
4
5
6
7
8
| @Test
public void testOf() {
int sum = IntStream.of(1).sum();
System.out.println(sum);
sum = IntStream.of(1, 2, 3, 4).sum();
System.out.println(sum);
}
|
5）empty() 创建一个空流。
1
2
3
4
5
| @Test
public void testEmpty() {
int sum = IntStream.empty().sum();
System.out.println(sum);
}
|
6）builder() 构造流。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| @Test
public void testBuilder() {
IntStream.Builder builder = IntStream.builder();
builder = builder.add(1);
builder = builder.add(2);
builder = builder.add(3);
IntStream build = builder.build();
int sum = build.sum();
System.out.println(sum);
sum = IntStream.builder().add(1).add(2).add(3).build().sum();
System.out.println(sum);
}
|
7）iterate() 创建一个无限流。
1
2
3
4
5
6
| @Test
public void testIterate() {
IntStream.iterate(1, (e) -> e * 2).limit(10).forEach(System.out::println);
}
|
8）concat() 合并两个流
1
2
3
4
5
6
7
8
| @Test
public void testConcat() {
IntStream a = IntStream.range(10, 20);
IntStream b = IntStream.range(40, 50);
long count = IntStream.concat(a, b).count();
Assert.assertEquals(20, count);
}
|
2.2 操作IntStream
2.2.1 过滤操作
1）filter() 过滤不满足条件的元素。
1
2
3
4
5
| @Test
public void testFilter() {
IntStream.of(1, 5, 3, 7, 8, 3, 5, 6).filter(e -> e >= 5).forEach(System.out::println);
}
|
2.2.2 转换操作
1）map
1
2
3
4
5
| @Test
public void testMap() {
IntStream.of(1, 2, 3).map(e -> e * 2).forEach(System.out::println);
}
|
2）mapToObj()
1
2
3
4
5
| @Test
public void testMapObject() {
IntStream.of(1, 2, 3).mapToObj(String::valueOf).map(String::getClass).forEach(System.out::println);
}
|
3）mapToLong()
1
2
3
4
5
| @Test
public void testMapToLong() {
IntStream.of(1, 2, 3).mapToLong(e -> e).forEach(System.out::println);
}
|
4）mapToDouble()
1
2
3
4
5
| @Test
public void testMapToDouble() {
IntStream.of(1, 2, 3).mapToDouble(e -> e).forEach(System.out::println);
}
|
5）asLongStream()
1
2
3
4
5
6
| @Test
public void testAsLongStream() {
long[] array = IntStream.range(10, 20).asLongStream().toArray();
Assert.assertEquals(10, array.length);
}
|
6）asDoubleStream() 快速转成 Double 类型的 Stream。
1
2
3
4
5
6
| @Test
public void testAsDoubleStream() {
double[] array = IntStream.range(10, 20).asDoubleStream().toArray();
Assert.assertEquals(10, array.length);
}
|
2.2.3 拍扁操作
1）flatMap()
1
2
3
4
5
| @Test
public void testFlatMap() {
IntStream.of(1, 2, 3).flatMap(e -> IntStream.rangeClosed(0, e)).forEach(System.out::println);
}
|
2.2.4 去重操作
1）distinct()
1
2
3
4
5
| @Test
public void testDistinct() {
long count = IntStream.of(1, 2, 2, 3).distinct().count();
Assert.assertEquals(3, count);
}
|
2.2.5 排序操作
1）sorted()
1
2
3
4
5
| @Test
public void testSorted() {
IntStream.of(5, 6, 3, 2, 7, -1, -6, 0).sorted().forEach(System.out::println);
}
|
2.2.6 查看元素
1）peek()
1
2
3
4
5
6
7
8
| @Test
public void testPeek() {
IntStream.of(1, 2, 3, 4, 5)
.filter(e -> e >= 3)
.peek(value -> System.out.printf("filter element: %d\n", value))
.mapToObj(String::valueOf)
.forEach(System.out::println);
}
|
2.2.7 限流操作
1）limit()
1
2
3
4
5
| @Test
public void testLimit() {
IntStream.range(0, 100000).limit(15).forEach(System.out::println);
}
|
2.2.8 跳过操作
1
2
3
4
5
| @Test
public void testSkip() {
IntStream.range(0, 10).skip(5).forEach(System.out::println);
}
|
2.2.9 遍历操作
1）forEach()
1
2
3
4
| @Test
public void testForEach() {
IntStream.of(1,5,-9,0,-5,2,5,8).forEach(System.out::println);
}
|
2）forEachOrdered()
1
2
3
4
5
6
7
8
| @Test
public void testForEachOrdered() {
IntStream.of(1,5,-9,0,-5,2,5,8).parallel().forEach(System.out::println);
System.out.println("===================================================");
IntStream.of(1,5,-9,0,-5,2,5,8).parallel().forEachOrdered(System.out::println);
}
|
2.2.10 数组操作
1
2
3
4
5
| @Test
public void testToArray() {
int[] array = IntStream.range(0, 100).toArray();
Assert.assertEquals(100, array.length);
}
|
2.2.11 规约操作
1
2
3
4
5
6
7
8
| @Test
public void testReduce() {
int sum = IntStream.range(0, 1000).reduce(0, (v1, v2) -> v1 + v2);
System.out.println(sum);
IntStream.range(0, 1000).reduce((v1, v2) -> v1 + v2).ifPresent(System.out::println);
}
|
2.2.12 收集操作
1）collect() 自定义逻辑。
1
2
3
4
5
6
7
| @Test
public void testCollect() {
Stream<Integer> stream = IntStream.range(0, 100).boxed();
ArrayList<Integer> list = stream.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
Assert.assertEquals(100, list.size());
}
|
2）collect() 传入 Collectors。
1
2
3
4
5
6
7
| @Test
public void testCollectWithCollectors() {
ArrayList<Integer> list = IntStream.range(0, 100).boxed().collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
list.forEach(System.out::println);
IntStream.range(0, 100).boxed().collect(Collectors.toList());
}
|
2.2.13 数学操作
1）sum()
1
2
3
4
5
| @Test
public void testSum() {
int sum = IntStream.rangeClosed(0, 10).sum();
Assert.assertEquals(55, sum);
}
|
2.2.14 匹配操作
1）anyMatch()
1
2
3
4
5
| @Test
public void testAnyMatch() {
boolean result = IntStream.of(-2, 2, -9, 10, 9).anyMatch(e -> e > 0);
Assert.assertTrue(result);
}
|
2）allMatch()
1
2
3
4
5
| @Test
public void testAllMatch() {
boolean result = IntStream.of(5, 5, 5, 5, 5).anyMatch(e -> e > 0);
Assert.assertTrue(result);
}
|
3）noneMatch()
1
2
3
4
5
| @Test
public void testNoneMath() {
boolean result = IntStream.of(4, 5, 5, 5).noneMatch(e -> e == 4);
Assert.assertFalse(result);
}
|
2.2.15 查询操作
1）findFirst()
1
2
3
4
5
| @Test
public void testFindFirst() {
int element = IntStream.of(4, 5, 5, 5).findFirst().getAsInt();
Assert.assertEquals(4, element);
}
|
2）findAny()
1
2
3
4
| @Test
public void testFindAny() {
IntStream.range(0, 18).findAny().ifPresent(System.out::println);
}
|
2.2.16 装箱操作
1）boxed() 将元素装箱。
1
2
3
4
5
6
| @Test
public void testBoxed() {
boolean result = IntStream.range(0, 10).boxed().allMatch((e -> e instanceof Integer));
Assert.assertTrue(result);
}
|