JDK8辅助学习(七)：IntStream

已于 2023-09-18 17:04:33 修改
阅读量4.2k 收藏 36
点赞数 8
分类专栏： JDK8新特性 文章标签： jdk8
于 2021-03-31 15:25:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzb348110175/article/details/115324141
版权

本文目录

本章节我们提供一些 Java 8 中的 IntStream、LongStream 和 DoubleStream 使用范例。IntStream、LongStream 和 DoubleStream 分别表示原始 int 流、 原始 long 流 和 原始 double 流。

这三个原始流类在 java.util.stream 命名空间下，并提供了大量的方法用于操作流中的数据，同时提供了相应的静态方法来初始化它们自己。

本文仅介绍IntStream的方法，LongStream/DoubleStream 的使用同 IntStream 一致，此处不再过多介绍。

1.创建IntStream流(IntStream中的静态方法：of / builder/ range / rangeClosed / generate / iterate)

 创建IntStream流的几种方式，如下：

1. IntStream.of()方式

// 支持一个参数，也支持可变参数
IntStream intStream = IntStream.of(1);
IntStream intStream = IntStream.of(1,2,3,4,5,6,7);

2. IntStream.builder()方式 (了解即可)

// 1.可以使用add()方法添加元素
IntStream builderStream= builder.add(111).add(222).add(333).add(444).build();
// 2.也可以使用accept()方式添加，add()方法底层也是通过accept()方式添加的（这种方式不支持链式调用，此处了解一下即可）
IntStream.Builder builder = IntStream.builder();
builder.accept(3);
builder.accept(4);
builder.accept(5);
IntStream builderStream = builder.build();

3. IntStream.range()、IntStream.rangeClosed()方式
 将指定范围内的元素都添加到int流中
 range()前者不包含最后一个元素，即：前闭后开区间；
 rangeClosed()后者包含，即：前闭后闭区间；

// 支持一个参数，也支持可变参数
IntStream range = IntStream.range(1, 100);    // 返回 1,2,3,4,......,99
IntStream range = IntStream.rangeClosed(1, 100);    // 返回 1,2,3,4,......,99,100

4. IntStream.generate()方式 (了解即可)

// 1.这种方式，是无限连续的流，会源源不断的生成100内的随机数(持续不断输出)
IntStream generate1 = IntStream.generate(() -> new Random().nextInt(100));
// 2.使用limit()会限制流中元素的数量
IntStream generate1 = IntStream.generate(() -> new Random().nextInt(100)).limit(6);

5. IntStream.iterate()方式
 指定生成int流中int元素的生成函数，前者的生成函数没有入参，后者会将前一次调用结果作为下一次调用生成函数的入参
 第一个参数seed，就是第一次调用生成函数的入参

// 规则：生成2的幂次方int流
// 根据指定规则，生成一串int流（使用iterate()方式，也是无限连续的流，需使用limit()来限制元素的数量)
IntStream intStream11 = IntStream.iterate(1,x->{
	int a = 2 * x;
	return a;
}).limit(6);
// 简写：
IntStream intStream11 = IntStream.iterate(1,x->2 * x).limit(6);

6. IntStream.concat()方式 (将两个int流合并成一个流)

// 将A流和B流合并，生成新流
IntStream range1 = IntStream.range(1, 5);   // A流
IntStream range2 = IntStream.range(10, 15);   // B流
IntStream concat = IntStream.concat(range1, range2);   // 合并后的流

2.filter

filter() 方法，用于过滤数据，返回符合过滤条件的数据，是一个非终结方法。我们可以通过 filter() 方法将一个流转换成另一个子集流。该接口接收一个 Predicate 函数式接口参数(可以是一个 Lambda 或 方法引用) 作为筛选条件。因为 filter() 是一个非终结方法，所以必须调用终止方法。示例如下：

@Test
public void test(){
    // 获取1-9的int流
    IntStream intStream = IntStream.range(1, 10);
    // 通过filter方式过滤掉小于5的数字,并输出
    intStream.filter(x->x>5).forEach(System.out::println);
}

输出结果:

6
7
8
9

3.map

IntStream 中的map()方法用于对流中的所有元素执行某个修改操作，这与 Stream 中的map()方法有所不同。Stream 中的map() 方法，参考：JDK8新特性(三)：集合之 Stream 流式操作

@Test
public void test02() {
    IntStream intStream = IntStream.range(1, 10);
    // 使用map(),将流中的数据*2返回
    intStream.map(new IntUnaryOperator() {
        @Override
        public int applyAsInt(int value) {
            return 2 * value;
        }
    }).forEach(System.out::println);

    // 简写
    intStream.map(o -> 2 * o).forEach(System.out::println);
}

输出结果:

2
4
6
8
10
12
14
16
18

4.flatMap

flatMap() 方法同 map() 方法。
 
区别在于：flatMap() 方法的返回值是一个 IntStream 而非 int 值，可以在返回的IntStream 中包含多个元素，flatMap() 方法最终返回的 IntStream 是将每次调用 flatMap() 方法返回的 IntStream 合并后的结果。

@Test
public void test03() {
    IntStream intStream = IntStream.range(1, 10);
    // 使用flatMap(),将流中的数据*2返回
    intStream.flatMap(new IntFunction<IntStream>() {
        @Override
        public IntStream apply(int value) {
            return IntStream.of(2 * value);
        }
    }).forEach(System.out::println);
    // 简写
    intStream.flatMap(o -> IntStream.of(2 * o)).forEach(System.out::println);
}

输出结果:

2
4
6
8
10
12
14
16
18

5.peek

介绍：该方法会生成一个包含原 Stream 的所有元素的新 Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；
 
存在此方法的目的，主要是为了在您需要的地方支持调试，查看元素流过管道中特定点的情况
 
主要用于开发过程中调试使用！！！

@Test
public void test04() {
    IntStream intStream = IntStream.range(1, 10);
    long count = intStream.filter(x -> x > 5)
            .peek(val -> System.out.println("是否>5:" + val))
            .count();
	System.out.println("过滤后总数为:" + count);
}

输出结果:

是否>5:6
是否>5:7
是否>5:8
是否>5:9
过滤后总数为:4

6.mapToObj / mapToLong / mapToDouble / asLongStream / asDoubleStream

1.mapToObj：将 int 流转换成其他类型的流 (其他类型：可以使自定义对象类型，也可以是List类型等)
2.mapToLong：将 int 流转换成Long类型的流，不可指定返回值规则  (挺简单的，此处不做demo演示)
3.mapToDouble：将 int 流转换成Double类型的流，不可指定返回值规则  (挺简单的，此处不做demo演示)
4.asLongStream：将 int 流转换成Long类型的流，该方法遵循标准的int到指定类型的转换规则，不能指定规则，比如说将int流对象先 乘以2再返回  (挺简单的，此处不做demo演示)
5.asDoubleStream：将 int 流转换成Double类型的流，该方法遵循标准的int到指定类型的转换规则，不能指定规则，比如说将int流对象先 乘以2再返回  (挺简单的，此处不做demo演示)

// mapToObj()方法演示
@Test
public void test06() {
    IntStream intStream = IntStream.range(1, 10);
    // mapToObj():将int流转换成Person对象
    intStream.mapToObj(val -> new Person(val, "Mary" + val))
            .forEach(System.out::println);
}

// Person类
public class Person {

    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

// mapToLong / mapToDouble / asLongStream / asDoubleStream()方法演示
// 一个stream流只能被消费一次,以下是伪代码,会报错。
@Test
public void test07() {
    IntStream intStream = IntStream.range(1, 10);
    // mapToLong()方法(可指定返回值规则)
    intStream.mapToLong(val -> 2 * val).forEach(System.out::println);
    
    // mapToDouble()方法(可指定返回值规则)
    intStream.mapToDouble(val -> 2 * val).forEach(System.out::println);
    
    // asDoubleStream()方法(不可指定返回值规则)
    intStream.asDoubleStream().forEach(System.out::println);
    
    // asLongStream()方法(不可指定返回值规则)
    intStream.asLongStream().forEach(System.out::println);
}

7.forEach / forEachOrdered

这两个方法都是用来遍历流中的元素，是一个终结方法。该方法接收一个 IntConsumer 接口函数，会将每一个流元素交给该函数进行处理。
1.forEach：遍历流中的元素
2.mapToLong：forEachOrdered同forEach的区别在于并行流处理下，forEachOrdered会保证实际的处理顺序与流中元素的顺序一致，而forEach方法无法保证，默认的串行流处理下，两者无区别，都能保证处理顺序与流中元素顺序一致。

@Test
public void test08() {
    IntStream intStream = IntStream.of(2,6,3,5,9,8,1).parallel();
    intStream.forEach(x->{
        System.out.println("forEach->"+x);
    });

    // forEachOrdered()同forEach()方法
    // 区别：在于并行流处理下,forEachOrdered会保证实际的处理顺序与流中元素的顺序一致
    // 而forEach方法无法保证,默认的串行流处理下,两者无区别,都能保证处理顺序与流中元素顺序一致
    IntStream intStream1 = IntStream.of(2,6,3,5,9,8,1).parallel();
    intStream1.forEachOrdered(x->{
        System.out.println("forEachOrdered->"+x);
    });
}

输出结果:

forEach->9
forEach->5
forEach->2
forEach->1
forEach->8
forEach->3
forEach->6
forEachOrdered->2
forEachOrdered->6
forEachOrdered->3
forEachOrdered->5
forEachOrdered->9
forEachOrdered->8
forEachOrdered->1

8.distinct

distinct() 方法，可以用来去除重复数据。因为 distinct() 方法是一个非终结方法，所以必须调用终止方法。

@Test
public void test09() {
    IntStream intStream = IntStream.of(1, 2, 3, 4, 5, 6, 1, 4, 5, 2);
    intStream.distinct().forEach(System.out::println);
}

输出结果:

1
2
3
4
5
6

9.sorted

sorted() 方法，可以用来对 Stream 流中的数据进行排序。
Stream流中的sorted()方法，还允许我们自定义Comparator规则进行排序；参考:JDK8新特性(三)：集合之 Stream 流式操作 中的sorted()方法
IntStream流中的sorted()方法，就是纯粹对int数值进行排序，所以也没有Comparator自定义比较器排序的必要

@Test
public void test10() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    intStream.sorted().forEach(System.out::println);
}

输出结果：

1
2
4
5
9
35

10.limit

limit()方法，用来对 Stream 流中的数据进行截取，只取用前 n 个，是一个非终结方法。参数是一个 long 型，如果集合当前长度大于参数则进行截取，否则不进行操作。因为 limit() 是一个非终结方法，所以必须调用终止方法

@Test
public void test11() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    // limit()截取,截取IntStream流中的前4个元素
    intStream.limit(4).forEach(System.out::println);
}

输出结果：

1
9
4
35

11.skip

如果希望跳过前几个元素，去取后面的元素，则可以使用 skip()方法，获取一个截取之后的新流，它是一个非终结方法。参数是一个 long 型，如果 Stream 流的当前长度大于 n，则跳过前 n 个，否则将会得到一个长度为 0 的空流。因为 limit() 是一个非终结方法，所以必须调用终止方法。

@Test
public void test11() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    // skip()跳过流中前2个元素,获取剩下的元素
    intStream.skip(2).forEach(System.out::println);
}

输出结果：

4
35
5
2

备注：

   skip() 和 limit() 配合使用，即可实现类似分页的操作了

//一页10条 分页操作
//第一页
skip(0).limit(10)
//第二页
skip(10).limit(10)
//第三页
skip(20).limit(10)
...

12.reduce

reduce方法，用于执行类似于累加的操作，上一次调用处理函数的结果会作为入参下一次调用的入参；
 
reduce方法，有如下两个不同参数的方法供调用

int reduce(int identity, IntBinaryOperator op);
OptionalInt reduce(IntBinaryOperator op);

参数说明：
1.int identity：初始值（是否需要设置初始值，视情况而定）
2.IntBinaryOperator op：计算规则
 
方法说明：
1.方法1有初始值，返回值为int
2.方法2无初始值，有可能为空的情况，所以返回 OptionalInt 类型

@Test
public void test22() {
    // IntStream流
    IntStream intStream = IntStream.of(1, 1, 1, 1, 1, 1);

    // 1.设置初始值为10,(求和则会在10的基础上进行计算,计算结果为16,返回值类型为int)
    // 基础写法
    int reduce = intStream.reduce(10, new IntBinaryOperator() {
        @Override
        public int applyAsInt(int left, int right) {
            return left + right;
        }
    });
    System.out.println(reduce);    // 16

    // 简写
    IntStream intStream1 = IntStream.of(1, 1, 1, 1, 1, 1);
    int reduce1 = intStream1.reduce(10, Integer::sum);
    System.out.println(reduce1);    // 16
    
    // 2.无初始值(因为返回值可能为空,所以返回类型为OptionInt)
    // 因为没有初始值,int类型默认为0,所以计算结果为6
    IntStream intStream2 = IntStream.of(1, 1, 1, 1, 1, 1);
    OptionalInt reduce2 = intStream2.reduce(Integer::sum);
    System.out.println(reduce2.getAsInt());    // 6
}

分析过程：
在这里插入图片描述

13.sum / min / max / count / average / summaryStatistics

sum：求和
min：求最小值
max：求最大值
count：计算IntStream流中元素个数
average：求平均值
summaryStatistics：该方法一次调用获取上述5个属性值

@Test
public void test11() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    // sum:求和
    int sum = intStream.sum();
    System.out.println("sum -> " + sum);
    
    // min:最小值
    IntStream intStream1 = IntStream.of(1, 9, 4, 35, 5, 2);
    OptionalInt min = intStream1.min();
    System.out.println("min -> " + min.getAsInt());
    
    // max:最大值
    IntStream intStream2 = IntStream.of(1, 9, 4, 35, 5, 2);
    OptionalInt max = intStream2.max();
    System.out.println("max -> " + max.getAsInt());
    
    // count:统计流中元素个数
    IntStream intStream3 = IntStream.of(1, 9, 4, 35, 5, 2);
    long count = intStream3.count();
    System.out.println("count -> " + count);
    
    // average:统计流中元素个数
    IntStream intStream4 = IntStream.of(1, 9, 4, 35, 5, 2);
    OptionalDouble average = intStream4.average();
    System.out.println("average -> " + average.getAsDouble());
    
    // summaryStatistics:汇总方法,一次性返回sum/min/max/count/average值
    // average:统计流中元素个数
    IntStream intStream5 = IntStream.of(1, 9, 4, 35, 5, 2);
    IntSummaryStatistics intSummaryStatistics = intStream5.summaryStatistics();
    System.out.println("summaryStatistics -> " + intSummaryStatistics.toString());
    System.out.println("summaryStatistics.sum -> " + intSummaryStatistics.getSum());
    System.out.println("summaryStatistics.min -> " + intSummaryStatistics.getMin());
    System.out.println("summaryStatistics.max -> " + intSummaryStatistics.getMax());
    System.out.println("summaryStatistics.count -> " + intSummaryStatistics.getCount());
    System.out.println("summaryStatistics.average -> " + intSummaryStatistics.getAverage());
}

输出结果：

sum -> 56
min -> 1
max -> 35
count -> 6
average -> 9.333333333333334
summaryStatistics -> IntSummaryStatistics{count=6, sum=56, min=1, average=9.333333, max=35}
summaryStatistics.sum -> 56
summaryStatistics.min -> 1
summaryStatistics.max -> 35
summaryStatistics.count -> 6
summaryStatistics.average -> 9.333333333333334

14.anyMatch / allMatch / noneMatch

这三个方法，均返回 boolean 类型
allMatch：流中的所有元素都满足给定的匹配条件
anyMatch：流中是否存在任何一个元素满足匹配条件
noneMatch：流中的所有元素都不满足给定的匹配条件

@Test
public void test12() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    // allMatch:流中是否所有元素都 > 10
    boolean allMatch = intStream.allMatch(val -> val > 10);
    System.out.println("allMatch -> " + allMatch);
    
    // anyMatch:流中是否存在一个元素 > 10
    IntStream intStream1 = IntStream.of(1, 9, 4, 35, 5, 2);
    boolean anyMatch = intStream1.anyMatch(val -> val > 10);
    System.out.println("anyMatch -> " + anyMatch);
    
    // noneMatch:流中元素是否都不满足给定条件(流中元素都<10)
    IntStream intStream2 = IntStream.of(1, 9, 4, 35, 5, 2);
    boolean noneMatch = intStream2.noneMatch(val -> val > 10);
    System.out.println("noneMatch -> " + noneMatch);
}

输出结果：

allMatch -> false
anyMatch -> true
noneMatch -> false

15.findFirst / findAny

IntStream流中的这两个方法，均返回 OptionalInt 类型
findFirst：返回IntStream流中的第一个元素，如果流中数据为空，返回空OptionalInt
findAny：返回的元素是不确定的，对于同一个列表多次调用findAny()有可能会返回不同的值。使用findAny()是为了更高效的性能。如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行的情况，那就不能确保是第一个

@Test
public void test13() {
    // findFirst:返回流中的第一个元素
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    OptionalInt first = intStream.findFirst();
    System.out.println("findFirst -> " + first.getAsInt());

    // findAny:串行地情况下，一般会返回第一个结果.如果是并行的情况，那就不能确保是第一个
    IntStream intStream1 = IntStream.of(1, 9, 4, 35, 5, 2).parallel();
    OptionalInt any = intStream1.findAny();
    System.out.println("findAny -> " + any.getAsInt());
}

输出结果：

findFirst -> 1
findAny -> 35

16.sequential / parallel

sequential：串行(默认为串行，可以不使用sequential()方法)
parallel：并行

/**
 * sequential:串行
 */
@Test
public void test14() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    
    long start = System.currentTimeMillis();
    intStream.sequential().forEach(val -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":" + val);
    });
    long end = System.currentTimeMillis();
    System.out.println("sequential串行,用时:" + (end - start) + "ms");
}

输出结果：

main:1
main:9
main:4
main:35
main:5
main:2
sequential串行,用时:6037ms

分析：

sequential串行：只有main主线程执行，共耗时6037ms

/**
 * parallel:并行
 */
@Test
public void test15() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);

    long start = System.currentTimeMillis();
    intStream.parallel().forEach(val -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":" + val);
    });
    long end = System.currentTimeMillis();
    System.out.println("parallel并行,用时:" + (end - start) + "ms");
}

执行结果：

ForkJoinPool.commonPool-worker-2:2
ForkJoinPool.commonPool-worker-3:1
ForkJoinPool.commonPool-worker-1:9
ForkJoinPool.commonPool-worker-5:4
ForkJoinPool.commonPool-worker-4:5
main:35
parallel并行,用时:1033ms

分析：

parallel并行：共启动6个线程，共耗时1033ms

17.iterator

iterator： 迭代器，遍历返回流中的元素

@Test
public void test16() {
    // iterator:迭代器
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    PrimitiveIterator.OfInt iterator = intStream.iterator();
    while (iterator.hasNext()) {
        Integer next = iterator.next();
        System.out.println("iterator迭代数据:" + next);
    }
}

输出结果：

iterator迭代数据:1
iterator迭代数据:9
iterator迭代数据:4
iterator迭代数据:35
iterator迭代数据:5
iterator迭代数据:2

18.boxed

boxed：翻译过来是盒子被包装的意思。即：返回由IntStream流中的元素组成的Stream流，每个box 都装着Integer类
在Stream流中，是没有boxed()方法的；
只有在IntStream、DoubleStream、LongStream 这三种类型的流中，才有boxed()方法

源码：

@Override
public final Stream<Integer> boxed() {
    return mapToObj(Integer::valueOf);
}

解析：

①IntStream流中存的是 int 类型的 Stream，而Steam<Integer>是一个存了Integer的Stream。
②看源码发现，boxed()的作用就是将int类型的Stream转成了Integer类型的Stream。
②即：将IntStream转换成Stream<Integer>的过程，该过程也可通过上面介绍到的mapToObj()方法来实现

@Test
public void test17() {
    // boxed:返回一个流中元素的包装类的流(即：将IntStream转成Stream<Integer>类型)

    // 1.通过mapToObj()方法的方式返回Stream<xxx>类型
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    intStream.mapToObj(Integer::valueOf).collect(Collectors.toList()).forEach(System.out::println);

    // 2.通过boxed()方法的方式返回Stream<Integer>类型
    IntStream intStream1 = IntStream.of(1, 9, 4, 35, 5, 2);
    Stream<Integer> boxed = intStream1.boxed();  // 看这里,通过boxed返回的是Stream<Integer>类型
    List<Integer> collect = boxed.collect(Collectors.toList()); // 转换成List<Integer>类型
}

扩展：

@Test
public void test18() {
    // IntStream 转 Stream<Integer>
    IntStream intStream = IntStream.of(111, 222);
    Stream<Integer> boxed = intStream.boxed();
    // Stream<Integer> 转 IntStream
    Stream<Integer> integerStream = Stream.of(1111, 222);
    IntStream intStream1 = integerStream.mapToInt(Integer::valueOf);
}

19.toArray

toArray：将IntStream流中的元素转换成一个数组

@Test
public void test19() {
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);
    // toArray:将IntStream流中的元素转换成一个数组
    int[] intArray = intStream.toArray();
    System.out.println(Arrays.toString(intArray));
}

输出结果：

[1, 9, 4, 35, 5, 2]

20.close / onClose

close：用于关闭Stream流，
onClose：该方法用于注册一个回调函数，它返回的是一个新的流，可以连续调用onClose，注册多个回调方法

@Test
public void test21() {
    // IntStream流
    IntStream intStream = IntStream.of(1, 9, 4, 35, 5, 2);

    // 使用onClose()方法注册多个回调函数
    IntStream newStream = intStream
                            .onClose(() -> System.out.println("1"))
                            .onClose(() -> System.out.println("2"))
                            .onClose(() -> System.out.println("3"));

    // 调用close()方法关闭流时,会一次执行注册的回调函数
    newStream.close();

    // 关闭流后,就不能再使用该流了(此处会报错:stream has already been operated upon or closed)
    int sum = newStream.sum();

}

输出结果：

// 关闭流时的回调函数内容
1
2
3
// 报错信息
java.lang.IllegalStateException: stream has already been operated upon or closed

21.collect

collect：用于将流中最终计算好的数据进行收集，并返回
 
collect() 方法的使用，也有很多内容学习，此处内容过多，不做一一列举。
在使用collect()方法时，我们会常用到一个Collectors工具类，该工具类为我们提供了很多日常开发中会用到的一些方法
 
比如说：
1.将结果收集到List集合
2.将结果收集到Set集合
3.将结果收集到Collection集合中
4.将结果进行聚合计算后返回
… … 等很多工具类，挺好用的。
 
此处不过多介绍。请参考：JDK8辅助学习(四)：Stream流 collect() 方法的详细使用介绍
 
Example：此处来一个简单的案例，将strem流计算返回的结果，收集到List集合中

@Test
public void test23() {
    // IntStream流
    IntStream intStream = IntStream.of(2, 9, 12, 35, 38, 8, 13, 39, 58, 86, 63);

    // 操作
    List<Integer> collect = intStream.filter(val -> val > 10)  // 过滤掉<10的,返回:12, 35, 38, 13, 39, 58, 86, 63
            .map(val -> 2 * val)   // 翻倍,返回:24, 70, 76, 26, 78, 116, 172, 126
            .skip(2)  // 跳过前2个,返回:76, 26, 78, 116, 172, 126
            .limit(4)  // 截取前4个,返回:76, 26, 78, 116
            .boxed()  // IntStream 转 Stream<Integer>
            .collect(Collectors.toList());  // 将结果收集至List集合

    // 输出
    collect.forEach(System.out::println);
}

输出结果：

76
26
78
116

Collectors工具类的使用，更多内容请参考：JDK8辅助学习(四)：Stream流 collect() 方法的详细使用介绍

博主写作不易，加个关注呗

求关注、求点赞，加个关注不迷路 ヾ(◍°∇°◍)ﾉﾞ

我不能保证所写的内容都正确，但是可以保证不复制、不粘贴。保证每一句话、每一行代码都是亲手敲过的，错误也请指出，望轻喷 Thanks♪(･ω･)ﾉ

扛麻袋的少年
关注
专栏目录
docker 常用镜像下载： jdk8-alpine3.9
06-01
加载镜像：docker load -i jdk8.tar
IntStream用法
wang0907的博客
03-30 6979
写在前面 IntStream是一种特殊的stream，用来提供对int相关的stream操作，下面我们一起来看下。 1：生成IntStream 1.1：IntStream.generate 用来生成无限个数整数对应的stream，对于需要持续获取随机值的场景可以考虑使用这种方式。 1.1.1：测试代码 class FakeCls { void fakeMethod() { Random random = new Random(); IntStream.generate
IntStream的用法(详解)
pzl1426733135的博客
10-10 3582
IntStream是一种特殊的Stream，用来提供对int类型数据进行相关的stream操作，下面我们一起来看下。
Java 8使用IntStream类介绍、应用场景和示例代码
最新发布
a_beiyo的博客
08-09 224
IntStream是一个特化的Stream接口，用于操作int类型的数据。它位于包中，提供了一组丰富的方法来处理整数流，如映射、过滤、聚合等。IntStream提供了丰富的操作方法来处理整数流，能够简化数值计算、数据转换、过滤、聚合等操作。它是 Java 8 引入的函数式编程特性之一，利用流式处理可以编写更加清晰和简洁的代码，提升代码的可读性和可维护性。
Java8 Stream API 之 IntStream 用法全解
热门推荐
菜鸟进阶之路
05-31 2万+
目录 1、创建int流 2、filter /map /flatMap /peek 3、mapToObj /mapToLong / mapToDouble/asLongStream /asDoubleStream 4、forEach /forEachOrdered 5、 reduce /collect 6、distinct /sorted /limit /skip 7、sum /min /max /count /average /summaryStatisti...
IntStream.range()和IntStream.rangeClosed()的区别
nanZhaiXiaoLang的博客
02-25 1535
IntStream.range()和IntStream.rangeClosed()的区别 IntStream.range() 是创建一个数字流 如果传的参数是1，10. 那么输出的是1-9 也就是开区间 [1,10) IntStream.range() 是创建一个数字流 如果传的参数是1，10. 那么输出的是1-10 也就是闭区间 [1,10] ...
java 中closed_Java中的IntStream rangeClosed()方法
weixin_35632603的博客
02-16 1467
的rangeClosed()在IntStream类返回类顺序排列IntStream从startInclusive到endInclusive通过的1递增步长这既包括startInclusive和endInclusive值。语法如下staticIntStreamrangeClosed(intstartInclusive,intendInclusive)在此，startInclusive是包括...
苹果系统JDK安装包下载（版本：jdk-8u321-macosx-x64）
03-14
本文将详细讲解苹果系统（MacOS）上安装Oracle JDK 1.8版本，特别是针对版本号为8u321的JDK-8u321-macosx-x64.dmg安装包。 首先，我们了解下Oracle JDK和OpenJDK的区别。Oracle JDK是官方的Java开发工具包，由甲骨...
JDK8安装包.zip
03-23
在Java编程领域，JDK8是极其重要的一个版本，它引入了许多新特性，提升了开发效率和程序性能。本文将详细介绍如何在Windows操作系统上安装JDK8，以及探讨其主要特性和应用。 **1. JDK8的下载与安装** 首先，你需要...
带字库依赖的jdk8镜像
02-06
官方的jdk8镜像没有自带字库，或者带字库的镜像非常巨大。所以自己构建了一个。 1. 自定义构建镜像的Dockerfile ``` FROM openjdk:8-jdk-alpine # 安装字体库 RUN apk add --update --no-cache ttf-dejavu ...
javajdk源码学习-JavaSourceLearn:JDK源码学习
05-24
jdk源码学习 JavaSourceLearn 版本号 版本 corretto-1.8.0_275 方式 逐步阅读源码添加注释、notes文件夹添加笔记 计划学习任务计划 标题为包名，后面序号为优先级1-4，优先级递减 java.lang Object 1 String 1 ...
Java8IntStream数值流的常用操作以及与装箱和拆箱的关系
BADAO_LIUMANG_QIZHI的博客
10-19 816
前面讲Stream的常用api的使用。在Stream中元素都是对象，那么当我们操作一个数字流的时候就要考虑拆箱和装箱。
如何在队列排队之前让ThreadPoolExecutor将线程增加到最大数量
yfy的博客
08-10 2835
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> w...
通过线程池方式改造Stream.parallel()并行流
学Java，找哪吒
10-12 2395
大家好，我是哪吒。上一篇简单聊一聊公平锁和非公平锁，parallel并行流，提到了一个IntStream.rangeClosed并行流问题，很多小伙伴，对这个比较陌生，想用线程池的方式改造一下。 二、线程池方式改造 不会那些新特性，还是原始的香啊，写起代码，得心应手。这时候，有些小伙伴，又陷入了选择恐惧症。用哪个线程池比较好呢？简单回顾一下：最常用的还是固定线程数线程池newFixedThreadPool(10)。 2、线程类 3、信心满满，走起来 我草，这不对啊，不应该是100000嘛？又把老子整不会了
Java 8 - IntStream,LongStream,DoubleStream
qq_33240556的博客
07-27 454
在 Java 8 中，IntStreamLongStream, 和是专门处理基本类型intlong, 和double的流。这些流是为了提高性能而设计的，因为它们避免了装箱/拆箱操作，这对于大量数据的处理尤其重要。IntStream是一种特殊的流，它用于处理int类型的数据。它提供了一系列方法来高效地操作整数序列。
Java中的IntStream函数：数值流操作详解
CyberSparkZ的博客
09-28 140
通过使用IntStream的各种操作方法，我们可以对整数流进行过滤、映射、排序、聚合等操作，从而实现各种复杂的数值计算和转换。在本文中，我们介绍了一些常用的IntStream函数操作方法，并提供了相应的源代码示例，帮助读者更好地理解和应用这些函数。它提供了一系列的操作方法，可以对整数流进行各种操作，如过滤、映射、排序、聚合等。map：对流中的每个元素应用指定的函数，并将结果映射到一个新的流中。filter：根据指定的条件过滤流中的元素，只保留满足条件的元素。forEach：对流中的每个元素执行指定的操作。
IntStream类
卢大宝宝的博客
05-31 494
支持顺序和并行聚合操作的原始int值元素序列 所属包：java.util.stream
Java8 新特性 —— Stream 流式编程
低吟不作语的博客
11-14 4546
本文部分摘自 On Java 8 流概述 集合优化了对象的存储，大多数情况下，我们将对象存储在集合是为了处理他们。使用流可以帮助我们处理对象，无需迭代集合中的元素，即可直接提取和操作元素，并添加了很多便利的操作，例如查找、过滤、分组、排序等一系列操作。 流的一个核心好处是：它使得程序更加短小并且易于理解，当结合 Lambda 表达式和方法引用时，会让人感觉自成一体。总而言之，流就是一种高效且易于使用的处理数据的方式。 观察下面的例子： public class Randoms { ..
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

扛麻袋的少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值