IntStream的用法详解

IntStream是一种特殊的Stream，用来提供对int类型数据进行相关的stream操作，下面我们一起来看下。

1生成IntStream

1.1IntStream.generate

用来生成无限个数整数对应的stream，对于需要持续获取随机值的场景可以考虑使用这种方式。

   public void testGenerate(){
        Random random=new Random();
        IntStream.generate(()->random.nextInt(1000)).limit(500).forEach(System.out::println);
    }

通过IntSupplier()->random::nextInt，生成无限个0到1000以内的整数，然后通过forEach获取。输出结果如下：

.......

296
90
46
28
66
343
207
315
530

.......

1.2IntStream.range

生成某个数字范围内的数字集合stream，range是左闭右开的，对应还有rangeClose，左闭右闭的。

  public static void testRangeAndRangeClosed(){
        System.out.println("左闭右开");
        IntStream.range(0,5).forEach(System.out::println);
        System.out.println("左闭右闭");
        IntStream.rangeClosed(0,5).forEach(System.out::println);
  }

输出如下:

左闭右开
0
1
2
3
4
左闭右闭
0
1
2
3
4
5

1.3Stream.of

使用一组给定值生成stream

public static void testOf(){
       IntStream.of(2,4,8,10).forEach(System.out::println);
}

输出如下:

2
4
8
10

1.4Stream.empty

生成不包含任何元素的空流

   public static void testEmpty(){
        int sum=IntStream.empty().sum();
        System.out.println(sum);
        IntStream.empty().forEach(System.out::println);
    }

输出如下:

1.5IntStream.builder

使用类似于建造者模式构建一个流，可以通过add方法添加多个元素，最后用build获取流对象。

 public static void testBuilder(){
       IntStream.builder().add(10).add(100).add(88).build().forEach(System.out::println);
    }

输出如下:

10
100
88

1.6IntStream.iterate

通过迭代函数，生成一个有序无限的Int数据流。（由于是无限流，一般都是配合limit来使用）

 public static void testIterate(){
        //参数一:seed初始值
        //参数二:IntUnaryOperator用前一个元素以生成新元素的函数
        //用limit截断,防止无限输出
        IntStream.iterate(1,x->x*4).limit(5).forEach(System.out::println);
    }

输出如下:

1
4
16
64
256

1.7IntStream.concat

和并流，使用concat方法将连个不同流合并为一个流输出

 public static void testConcat(){
        IntStream stream1=IntStream.of(12,55,10,14);
        IntStream stream2=IntStream.builder().add(10).add(8).add(15).build();
        IntStream.concat(stream1,stream2).forEach(System.out::println);
    }

输入如下:

12
55
10
14
10
8
15

2操作Stream

2.1过滤操作filter

通过filter来过滤不需要的元素，测试和输出如下:

    public static void testFilter(){
        //将下列大于等于60的元素筛选出来，并打印在控制台
        IntStream score = IntStream.of(88, 45, 60, 99, 59, 90);

        score.filter(x->x>=60).forEach(System.out::println);

    }

88
60
99
90

2.2转换map

map用于操作当前的所有元素，已给定操作生成新值，并用新值替换旧值。测试和输出如下:

  public static void testMap(){
        IntStream.rangeClosed(20,30).map(x->x*2).forEach(System.out::println);

    }

40
42
44
46
48
50
52
54
56
58
60

2.3mapToObj

mapObj可以将元素转换为其他任意类型，具体转换类型由实现类决定，测试代码和运行结果如下:

    public static void testMapToObj(){
        //mapToObj将int类型装换为String类型,也可转换为其他类型,由lambda表达式的返回结果决定
        Stream<String> stringStream = IntStream.rangeClosed(10, 15).mapToObj(e -> String.valueOf(e));
        stringStream.forEach(v->{
            System.out.println(v+" "+v.getClass());
        });
    }

10 class java.lang.String
11 class java.lang.String
12 class java.lang.String
13 class java.lang.String
14 class java.lang.String
15 class java.lang.String

2.4mapToLong

mapToLong顾名思义，将int类型转换为Long类型，测试和运行结果如下:

    public static void testMapToLong(){
        //隐式转换,在java中int类型占4个字节,long类型8个字节,jvm会将短精度类型自动转换为长精度类型
        //或者也可以用Long包装类的valueOf方法将int类型转换为long类型
        LongStream longStream = IntStream.rangeClosed(10, 15).mapToLong(e -> e*2);
        longStream.forEach(v->{
            System.out.println(v+" "+((Object)v).getClass());
        });
    }

20 class java.lang.Long
22 class java.lang.Long
24 class java.lang.Long
26 class java.lang.Long
28 class java.lang.Long
30 class java.lang.Long

2.5mapToDouble

同2.4MapToLong

2.6asLongStream

IntStream的asLongStream方法，直接将int流转换为long类型的流，测试和运行结果如下:

   public static void testAsLongStream(){
        LongStream longStream = IntStream.rangeClosed(8, 12).asLongStream();
        longStream.forEach(v->{
            System.out.println(v+" "+((Object)v).getClass());
        });
    }

8 class java.lang.Long
9 class java.lang.Long
10 class java.lang.Long
11 class java.lang.Long
12 class java.lang.Long

2.7asDoubleStream

2.6asLongStream同理

2.8扁平化操作flatMap

flatMap将IntStream流中的元素依次处理，并将其每个元素转换为一个流，最终将每个流合成一个大的IntStream返回，测试和运行结果如下:

  public static void testFlatMap(){

        IntStream.of(1,2,3).flatMap(e -> IntStream.rangeClosed(0,e)).forEach(System.out::println);

    }

0
1
0
1
2
0
1
2
3

2.9去重操作distinct

利用distinct对流中重复的元素进行去重，测试和运行结果如下:

    public static void testDistinct(){
        IntStream.of(99,88,60,99,90,60).distinct().forEach(System.out::println);
    }

99
88
60
90

2.10排序操作sort

用于给元素排序，测试和运行结果如下：

private static void testSort() {
        IntStream.of(9, 80, 34, 2, 24).sorted().forEach(System.out::println);
    }

2

9

24

34

80

2.11查看元素peek

该操作可以获取每个元素然后给定特定的操作，测试和运行结果如下:

  public static void testPeek(){
       /*
        注意:peek后必须添加遍历操作，不然不会有任何输出
        
        由于peek方法需要传入的是一个IntConsumer接口实现类,所以我们得实现IntConsumer的accept方法，然而peek方法并不会去帮我们去调用我们重写accept方法，
        而是返回一个IntStream的另一个实现类StatelessOp的子类，通过重写StatelessOp的opWrapSink方法，该方法返回一个Sink.ChainedInt静态内部类,通过
        重写Sink.ChainedInt的accept方法，该方法去帮我们调用了IntConsumer的accept方法。最后通过foreach方法的内部操作帮我们调用了Sink.ChainedInt的accept方法 
        (通过简单分析源码而来,有不详细的地方请自行查看源码)
        */
        IntStream.range(1,10).peek(e-> System.out.printf("filter map element:%d\n",e)).mapToObj(e->String.valueOf(e)).forEach(System.out::println);
    }

filter map element:1
1
filter map element:2
2
filter map element:3
3
filter map element:4
4
filter map element:5
5
filter map element:6
6
filter map element:7
7
filter map element:8
8
filter map element:9
9

2.12跳过元素skip

使用skip跳过指定个数的元素，测试和输出结果如下：

private static void testSkip() {
        IntStream.rangeClosed(1, 9).skip(6).forEach(System.out::println);
    }

7
8
9

2.13顺序输出forEachOrdered

并行处理parallel，并行流输出的元素并不能保证按照原始顺序输出，如果需要，则可以使用forEachOrdered保证输出顺序(初始状态的顺序)，测试和运行结果如下:

    public static void  testForEachOrdered(){
        System.out.println("forEach输出并行流中的元素");
        IntStream.of(5,10,20,4,19,50).parallel().forEach(value -> System.out.print(value+" "));
        System.out.println();
        System.out.println("forEachOrdered,按照初始顺序输出并行流:");
        IntStream.of(5,10,20,4,19,50).parallel().forEachOrdered(value -> System.out.print(value+" "));
    }

forEach输出并行流中的元素
4 19 50 5 20 10
forEachOrdered,按照初始顺序输出并行流:
5 10 20 4 19 50

2.14reduce规约

按照特点规则处理每个元素，然后返回处理后的结果，测试和运行结果如下:

public static void testReduce(){
        //求1到100的和
        System.out.println("1-100的和为:"+IntStream.rangeClosed(1,100).reduce((x,y)->x+y).getAsInt());
        //orElse和orElseGet可以防止返回值为空,如果为空则默认返回0
        System.out.println(IntStream.of().reduce((x, y) -> x + y).orElse(0));
        System.out.println(IntStream.of().reduce((x, y) -> x + y).orElseGet(() -> 0));
        System.out.println(IntStream.of().reduce((x, y) -> x + y).orElseThrow(()->new RuntimeException("参数为空,返回值为空")));
    }

1-100的和为:5050
0
0
Exception in thread "main" java.lang.RuntimeException: 参数为空,返回值为空
at Test.lambda$testReduce$19(Test.java:105)
at Test$$Lambda$6/1149319664.get(Unknown Source)
at java.util.OptionalInt.orElseThrow(OptionalInt.java:189)
at Test.testReduce(Test.java:105)
at Test.main(Test.java:8)

2.15装箱操作boxed

boxed用于将流中的元素转换为对应的对象类型，具体测试代码和输出如下：

 private static void testBoxed() {
        IntStream.of(2, 7).boxed().forEach(v -> System.out.println(v + " -> " + v.getClass()));
    }

2 -> class java.lang.Integer

7 -> class java.lang.Integer

2.16数学运算

最大值，最小值，平均值等数学操作，测试和输出如下

 private static void testMathOpt() {
        System.out.println("最大值：");
        System.out.println(IntStream.of(3, 90, 988, 1, 76).max().getAsInt());
        System.out.println("最小值：");
        System.out.println(IntStream.of(3, 90, 988, 1, 76).min().getAsInt());
        System.out.println("平均值：");
        System.out.println(IntStream.of(3, 90, 988, 1, 76).average().getAsDouble());
        System.out.println("元素个数：");
        System.out.println(IntStream.of(3, 90, 988, 1, 76).count());
        System.out.println("元素总和：");
        System.out.println(IntStream.of(3, 90, 988, 1, 76).sum());
        System.out.println("使用summaryStatistics进行数学运算：");
        IntSummaryStatistics summaryStatistics = IntStream.of(-2, 2, -9, 10, 9).summaryStatistics();
//        Assert.assertEquals(10, summaryStatistics.getSum());
        System.out.println("总和：" + summaryStatistics.getSum());
        System.out.println("最大值：" + summaryStatistics.getMax());
        System.out.println("最小值：" + summaryStatistics.getMin());
        System.out.println("元素个数：" + summaryStatistics.getCount());
        System.out.println("平均值：" + summaryStatistics.getAverage());
    }

最大值： 988

最小值： 1

平均值： 231.6

元素个数： 5

元素总和： 1158

使用summaryStatistics进行数学运算：

总和：10

最大值：10

最小值：-9

元素个数：5

平均值：2.0

2.17匹配操作

返回特定的元素，如首个元素等，测试和输出如下:

    private static void testMatchOpt() {
        boolean anyMatch = IntStream.of(-2, 2, -9, 10, 9).anyMatch(e -> e > 0);
//        Assert.assertTrue(result);
        System.out.println("anyMatch: " + anyMatch);
        boolean allMatch = IntStream.of(5, 5, 5, 5, 5).allMatch(e -> e > 0);
        System.out.println("allMatch: " + allMatch);
        boolean noneMatch = IntStream.of(4, 5, 5, 5).noneMatch(e -> e == 4);
        System.out.println("noneMatch: " + noneMatch);
    }

anyMatch: true

allMatch: true

noneMatch: false

2.18查询操作

返回特定的元素，如首个元素等，测试和输出如下：

private static void testFindOpt() {
        int findFirst = IntStream.of(4, 5, 5, 5).findFirst().getAsInt();
        System.out.println("findFirst: " + findFirst);
        int findAny = IntStream.of(42, 25, 52, 54).findAny().getAsInt();
        System.out.println("findAny: " + findAny);
    }

findFirst: 4

findAny: 42