JDK8辅助学习(七)：IntStream

已于 2023-09-18 17:04:33 修改
阅读量3.2k 收藏 30
点赞数 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♪(･ω･)ﾉ

扛麻袋的少年
关注
  • 8
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
JDK容器学习之Queue：LinkedBlockingQueue
06-19
JDK容器学习之Queue：LinkedBlockingQueue
IntStream用来提供对int类型数据进行相关的stream操作 && Map && mapToObj
一个搬砖工人
11-11 387
【代码】IntStream用来提供对int类型数据进行相关的stream操作 && Map && mapToObj。
Java新特性：Java8 Stream 简单快速的处理集合（三，字节跳动Java三面凉凉
最新发布
m0_60635176的博客
03-30 587
前面介绍的如计算元素总和的方法其中暗含了装箱成本，map(Person::getAge) 方法过后流变成了 Stream 类型，而每个 Integer 都要拆箱成一个原始类型再进行 sum 方法求和，这样大大影响了效率。针对这个问题 Java 8 有良心地引入了数值流 IntStream, DoubleStream, LongStream，这种流中的元素都是原始数据类型，分别是 int，double，long。当然如果是下面这样便会出错。
java多线程 并发基础
许诗宇的博客
02-10 692
注意：本文参考Java 并发常见知识点&面试题总结（基础篇） | JavaGuide 什么是线程和进程? 何为进程? 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当..
IntStream 的方法
赵丙双的博客
06-27 1344
上一篇介绍了 Stream 的用法，为了简化基本类型流使用，以及消除频繁自动装箱、拆箱的性能损耗，JDK 提供了三种基本类型的流：IntStream、 LongStream、DoubleStream。本篇将介绍一下 IntStream 中区别于 Stream 的方法。 IntStream 中的元素类型是基本类型的 int，所以对应的方法参数从 Predicate、Function、ToLongFunction、Consumer、Supplier… 变成了 IntPredicate、IntFunction、I
IntStream用法
wang0907的博客
03-30 6668
写在前面 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 3084
IntStream是一种特殊的Stream，用来提供对int类型数据进行相关的stream操作，下面我们一起来看下。
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 1414
IntStream.range()和IntStream.rangeClosed()的区别 IntStream.range() 是创建一个数字流 如果传的参数是1，10. 那么输出的是1-9 也就是开区间 [1,10) IntStream.range() 是创建一个数字流 如果传的参数是1，10. 那么输出的是1-10 也就是闭区间 [1,10] ...
Java8IntStream数值流的常用操作以及与装箱和拆箱的关系
BADAO_LIUMANG_QIZHI的博客
10-19 701
前面讲Stream的常用api的使用。在Stream中元素都是对象，那么当我们操作一个数字流的时候就要考虑拆箱和装箱。
JDK8 新特性学习.rar
01-19
如果你不会JDK1.8的新特性，这部资料绝对物超所值，里面有JDK1.8新特性的入门文档，还有自己整理的性能对比等给同事学习分享笔记，看完学习稍微实践一下，就可以完成入门到上手了，纯干货，5分不贵哈。
Jdk8下载(附：官网下载地址)
03-07
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
苹果系统JDK安装包下载（版本：jdk-8u321-macosx-x64）
03-14
MacOS系统Oracle JDK 1.8 官方版本下载，官网网速不好可以在此下载
JDK8安装包.zip
03-23
JDK8安装包
JDK8辅助学习(四)：Stream流 collect() 方法的详细使用介绍
热门推荐
扛麻袋的少年的博客
01-10 4万+
Stream流 collect() 方法的使用介绍 //1. <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); //2....
JDK8新特性(三)：集合之 Stream 流式操作
扛麻袋的少年的博客
01-07 1万+
1.Stream流由来 首先我们应该知道：Stream流的出现，主要是用在集合的操作上。在我们日常的工作中，经常需要对集合中的元素进行相关操作。诸如：增加、删除、获取元素、遍历。 最典型的就是集合遍历了。接下来我们先举个例子来看看 JDK8 Stream流式操作出现之前，我们对集合操作的过程，从中来了解一下JDK8 之前集合操作数据的弊端。 Demo...
JDK8新特性
扛麻袋的少年的博客
01-02 6089
1.Lambda表达式 JDK8以前，我们编写匿名内部类，看着很繁琐。 JDK8带来了Lambda表达式，编写代码更加简单，可以减少冗余代码。 参考：Lambda表达式 Lambda表达式原理分析 Lambda表达式----常用的内置函数式接口 ...
JDK8新特性(四)：Optional 类的使用
扛麻袋的少年的博客
01-12 5907
Optional类的使用 JDK8以前，编写代码，通常会出现 NullPointerException (空指针异常)，通常情况下我们都是通过 if ... else... 来对对象进行为空判断，然后再进行逻辑处理，代码写起来也比较冗余。 JDK8新增了Optional类，使用该类可以避免我们对空指针的检查，使代码看起来比较优雅。 1.Optional类介绍 ...
JDK8新特性(五)：JDK8时间日期API
扛麻袋的少年的博客
01-13 5022
前言 在 JDK8 之前，我们经常使用到的时间API包括(Date、Calendar)，Date 与字符串之间的转换使用 SimpleDateFormat 进行转换（parse()、format() 方法），然而 SimpleDateFormat 不是线程安全的。在设计上也是存在一些缺陷的，比如有两个 Date 类，一个在 java.util 包中，一个在 java.sql 包中。...
java jdk8 :: 的使用
04-05
Java JDK8是Java编程语言的开发套件，它包含了Java编译器、Java虚拟机、Java类库等工具和资源，用于开发和运行Java应用程序。以下是Java JDK8使用的一些基本步骤： 1. 下载和安装Java JDK8：从Oracle官网下载Java JDK8安装程序，然后按照安装向导进行安装。 2. 设置环境变量：在安装完成后，需要将JDK8的安装路径添加到系统的环境变量中，以便在命令行中使用Java命令和其他工具。 3. 编写Java程序：使用文本编辑器编写Java程序，保存为.java文件。 4. 编译Java程序：打开命令行窗口，使用javac命令编译Java程序，生成.class文件。例如：javac HelloWorld.java 5. 运行Java程序：使用java命令运行Java程序，例如：java HelloWorld 6. 调试Java程序：使用调试器调试Java程序，可以在代码中设置断点，单步执行程序，查看变量值等。 7. 打包Java程序：使用jar命令将Java程序打包成可执行的jar文件。例如：jar cvf myapp.jar *.class 8. 使用Java类库：Java JDK8包含了丰富的类库和API，可以使用这些类库来开发各种Java应用程序。例如：使用java.util包中的ArrayList类来管理动态数组。 以上是Java JDK8的基本使用步骤，可以根据实际需求进行调整和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

扛麻袋的少年

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

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

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

打赏作者

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

抵扣说明：

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

余额充值