Java8新特性-Stream

最新推荐文章于 2022-08-31 12:05:21 发布
最新推荐文章于 2022-08-31 12:05:21 发布
阅读量8.3k 收藏 133
点赞数 39
分类专栏： Java8新特性 文章标签： Stream Java8新特性-Stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ThinkWon/article/details/113798096
版权

文章目录

简介

Stream 作为 Java8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念，Stream 是对集合的包装，通常和lambda一起使用。使用stream可以支持许多操作，如 map, filter, limit, sorted, count, min, max, sum, collect 等等。

Stream 的特性

Stream 主要具有如下三点特性

  • stream不存储数据

  • stream不改变源数据

  • stream的延迟执行特性

通常我们在数组或集合的基础上创建stream，stream不会专门存储数据，对stream的操作也不会影响到创建它的数组和集合，对于stream的聚合、消费或收集操作只能进行一次，再次操作会报错

@Test
public void test1(){
    int[] arr = new int[]{1, 2, 3};
    IntStream intStream = Arrays.stream(arr);
    intStream.forEach(System.out::println);
    intStream.forEach(System.out::println);
}

输出结果

1
2
3


java.lang.IllegalStateException: stream has already been operated upon or closed

stream的操作是延迟执行的，在列出字符串长度大于3的例子中，在collect方法执行之前，filter、sorted、map方法还未执行，只有当collect方法执行时才会触发之前转换操作

public boolean filter(String s) {
    System.out.println("begin compare");
    return s.length() > 3;
}

@Test
public void test2() {
    List<String> strs = new ArrayList<String>() {
        {
            add("abc");
            add("abcd");
        }
    };
    Stream<String> stream = strs.stream().filter(this::filter);
    System.out.println("split-------------------------------------");
    List<String> list = stream.collect(Collectors.toList());
    System.out.println(list);
}

打印结果如下：

split-------------------------------------
begin compare
begin compare
[abcd]

由此可以看出，在执行完filter时，没有实际执行filter中的方法，而是等到执行collect时才会执行，即是延迟执行的。

注意：

  • 由于stream的延迟执行特性，在聚合操作执行前修改数据源是允许的。
  • 当我们操作一个流的时候，并不会修改流底层的集合（即使集合是线程安全的），如果想要修改原有的集合，就无法定义流操作的输出。
/**
 * 延迟执行特性，在聚合操作之前都可以添加相应元素
 */
@Test
public void test3() {
    List<String> wordList = new ArrayList<String>() {
        {
            add("a");
            add("b");
        }
    };

    Stream<String> words = wordList.stream();
    wordList.add("END");
    long n = words.distinct().count();
    System.out.println(n);
}

输出结果

3

延迟执行特性，会产生干扰

@Test
public void test4(){
    List<String> wordList = new ArrayList<String>() {
        {
            add("a");
            add("b");
        }
    };

    Stream<String> words1 = wordList.stream();
    words1.forEach(s -> {
        System.out.println("s->"+s);
        if (s.length() < 4) {
            System.out.println("select->"+s);
            wordList.remove(s);
            System.out.println(wordList);
        }
    });
}

输出结果

s->a
select->a
[b]
s->null


java.lang.NullPointerException

创建Stream

要进行流操作首先要获取流，有6中方法可以获取流。

通过集合创建流

@Test
public void testCollectionStream() {
    List<String> strs = Arrays.asList("a", "b", "c", "d");
    //创建普通流
    Stream<String> stream = strs.stream();
    //创建并行流（即多个线程处理）
    // Stream<String> stream1 = strs.parallelStream();
    stream.forEach(System.out::println);
}

输出结果

a
b
c
d

通过数组创建流

@Test
public void testArrayStream() {
    int[] arr = new int[]{1, 2, 3, 4};
    IntStream intStream = Arrays.stream(arr);
    intStream.forEach(System.out::println);

    System.out.println("========");
    Integer[] arr2 = new Integer[]{1, 2, 3, 4};
    Stream<Integer> stream = Arrays.stream(arr2);
    stream.forEach(System.out::println);
}

输出结果

1
2
3
4
========
1
2
3
4

通过Stream.of方法创建流

@Test
public void testStreamOf() {
    Stream<Integer> stream = Stream.of(1, 2, 3);
    stream.forEach(System.out::println);
}

输出结果

1
2
3

创建规律的无限流

@Test
public void testUnlimitStream() {
    Stream<Integer> stream = Stream.iterate(0, x -> x + 2).limit(3);
    stream.forEach(System.out::println);
}

输出结果

0
2
4

创建无限流

@Test
public void testUnlimitStream2() {
    Stream<String> stream = Stream.generate(() -> "number" + new Random().nextInt()).limit(3);
    stream.forEach(System.out::println);
}

输出结果

number1042047526
number-155761434
number-1605164634

创建空流

@Test
public void testEmptyStream() {
    Stream<Integer> stream = Stream.empty();
    stream.forEach(System.out::println);
}

Stream操作分类

  • 中间操作又可以分为无状态（Stateless）与有状态（Stateful）操作，
    • 无状态是指元素的处理不受之前元素的影响，
    • 有状态是指该操作只有拿到所有元素之后才能继续下去。
  • 终结操作又可以分为短路（Short-circuiting）与非短路（Unshort-circuiting）操作，
    • 短路是指遇到某些符合条件的元素就可以得到最终结果，
    • 非短路是指必须处理完所有元素才能得到最终结果。
  • 我们通常还会将中间操作称为懒操作，也正是由这种懒操作结合终结操作、数据源构成的处理管道（Pipeline），实现了 Stream 的高效。

中间操作

无状态

  • filter：过滤流，过滤流中的元素
  • map：转换流，将一种类型的流转换为另外一种类型的流
  • flapMap：拆解流，将流中每一个元素拆解成一个流
filter

filter接收一个Predicate函数接口参数，boolean test(T t);即接收一个参数，返回boolean类型。

@Test
public void testFilter() {
    Integer[] arr = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    Arrays.stream(arr).filter(x -> x > 3 && x < 8).forEach(System.out::println);
}

输出结果

4
5
6
7
map

map接收一个Function<T, R>函数接口，R apply(T t);即接收一个参数，并且有返回值。

@Test
public void testMap() {
    String[] arr = new String[]{"yes", "YES", "no", "NO"};
    Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);
}

输出结果

yes
yes
no
no
flapMap

flatMap接收一个Function<T, R>函数接口： Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);即入参为集合类型，返回Stream类型。

@Test
public void testFlatMap() {
    String[] arr1 = {"a", "b"};
    String[] arr2 = {"e", "f"};
    String[] arr3 = {"h", "j"};
    // Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
    Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
}

输出结果

a
b
e
f
h
j

有状态

  • distinct：元素去重
  • sorted：元素排序
  • limit：获取前面的指定数量的元素
  • skip：跳过前面指定数量的元素，获取后面的元素
  • concat：把两个stream合并成一个stream
distinct
@Test
public void testDistinct() {
    List<String> list = new ArrayList<String>() {
        {
            add("user1");
            add("user2");
            add("user2");
            add("user2");
        }
    };
    list.stream().distinct().forEach(System.out::println);
}

输出结果

user1
user2
sorted
sorted
@Test
public void testSorted1() {
    String[] arr1 = {"abc", "a", "bc", "abcd"};
    // 按照字符长度排序
    System.out.println("lambda表达式");
    Arrays.stream(arr1).sorted((x, y) -> {
        if (x.length() > y.length())
            return 1;
        else if (x.length() < y.length())
            return -1;
        else
            return 0;
    }).forEach(System.out::println);
    // Comparator.comparing是一个键提取的功能
    System.out.println("方法引用");
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
}

输出结果

lambda表达式
a
bc
abc
abcd
方法引用
a
bc
abc
abcd
reversed
/**
 * 倒序
 * reversed(),java8泛型推导的问题，所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
 * Comparator.reverseOrder():也是用于翻转顺序，用于比较对象（Stream里面的类型必须是可比较的）
 * Comparator.naturalOrder()：返回一个自然排序比较器，用于比较对象（Stream里面的类型必须是可比较的）
 */
@Test
public void testSorted2_() {
    String[] arr1 = {"abc", "a", "bc", "abcd"};
    System.out.println("reversed(),这里是按照字符串长度倒序排序");
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
    System.out.println("Comparator.reverseOrder(),这里是按照首字母倒序排序");
    Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
    System.out.println("Comparator.naturalOrder(),这里是按照首字母顺序排序");
    Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
}

输出结果

reversed(),这里是按照字符串长度倒序排序
abcd
abc
bc
a
Comparator.reverseOrder(),这里是按照首字母倒序排序
bc
abcd
abc
a
Comparator.naturalOrder(),这里是按照首字母顺序排序
a
abc
abcd
bc
thenComparing
/**
 * thenComparing
 * 先按照首字母排序
 * 之后按照String的长度排序
 */
@Test
public void testSorted3() {
    String[] arr1 = {"abc", "a", "bc", "abcd"};
   Arrays.stream(arr1).sorted(Comparator.comparing(this::firstChar).thenComparing(String::length)).forEach(System.out::println);
}

public char firstChar(String x) {
    return x.charAt(0);
}

输出结果

a
abc
abcd
bc
limit
/**
 * limit，限制从流中获得前n个数据
 */
@Test
public void testLimit() {
    Stream.iterate(1, x -> x + 2).limit(3).forEach(System.out::println);
}

输出结果

1
3
5
skip
/**
 * skip，跳过前n个数据
 */
@Test
public void testSkip() {
    Stream.iterate(1, x -> x + 2).skip(1).limit(3).forEach(System.out::println);
}

输出结果

3
5
7
concat
/**
 * 可以把两个stream合并成一个stream（合并的stream类型必须相同）
 * 只能两两合并
 */
@Test
public void testConcat(){
    // 1,3,5
    Stream<Integer> stream1 = Stream.iterate(1, x -> x + 2).limit(3);
    // 3,5,7
    Stream<Integer> stream2 = Stream.iterate(1, x -> x + 2).skip(1).limit(3);
    Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
}

输出结果

1
3
5
7

终结操作

非短路操作

  • forEach：遍历
  • toArray：将流转换为Object数组
  • reduce : 归约，可以将流中的元素反复结合起来，得到一个值
  • collect：收集，将流装换为其他形式，比如List，Set，Map
  • max：返回流的最大值，无方法参数
  • min：返回流中的最小值，无方法参数
  • count：返回流中的元素总个数，无方法参数
  • summaryStatistics：获取汇总统计数据，比如最大值，最小值，平均值等
forEach
@Test
public void testForEach() {
    List<String> list = new ArrayList<String>() {
        {
            add("a");
            add("b");
        }
    };
    list.stream().forEach(System.out::println);
}

输出结果

a
b
reduce
@Test
public void testReduce() {
    Optional<Integer> optional = Stream.of(1, 2, 3).filter(x -> x > 1).reduce((x, y) -> x + y);
    System.out.println(optional.get());
}

输出结果

5
collect

收集是非常常用的一个操作。 将流装换为其他形式。接收到一个Collector接口的实现，用于给Stream中的元素汇总的方法。用collect方法进行收集。方法参数为Collector。Collector可以由Collectors中的toList()，toSet()，toMap(Function(T,R) key,Function(T,R) value)等静态方法实现。

  • toList() 返回一个 Collector，它将输入元素到一个新的 List 。
  • toSet() 返回一个 Collector，将输入元素到一个新的 Set 。
  • toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper) 返回一个 Collector ，它将元素累加到一个 Map ，其键和值是将所提供的映射函数应用于输入元素的结果。

用户

@Data
@AllArgsConstructor
@ToString
public class User {
    private String name;
    private Integer age;
    private Integer salary;
}
toList，toSet，toSet
@Test
public void testCollect() {
    List<User> users = Arrays.asList(new User("张三", 19, 1000),
            new User("张三", 58, 2000),
            new User("李四", 38, 3000),
            new User("赵五", 48, 4000)
    );
    List<String> collect = users.stream().map(x -> x.getName()).collect(Collectors.toList());
    Set<String> collect1 = users.stream().map(x -> x.getName()).collect(Collectors.toSet());
    Map<Integer, String> collect2 = users.stream().collect(Collectors.toMap(x -> x.getAge(), x -> x.getName()));
    System.out.println(collect);
    System.out.println(collect1);
    System.out.println(collect2);
}

输出结果

[张三, 张三, 李四, 赵五]
[李四, 张三, 赵五]
{48=赵五, 19=张三, 38=李四, 58=张三}
groupingBy

Collectors.groupingBy()方法根据分类功能分组元素。这个是非常常用的操作。 比如你要对名字相同的进行分组。groupingBy(Function<? super T,? extends K> classifier)

@Test
public void testGroupby() {
    List<User> users = Arrays.asList(new User("张三", 19, 1000),
                                     new User("张三", 58, 2000),
                                     new User("李四", 38, 3000),
                                     new User("赵五", 48, 4000)
                                    );
    Map<String, List<User>> collect3 = users.stream().collect(Collectors.groupingBy(x -> x.getName()));
    System.out.println(collect3);
}

输出结果

{李四=[StreamTest.User(name=李四, age=38, salary=3000)], 张三=[StreamTest.User(name=张三, age=19, salary=1000), StreamTest.User(name=张三, age=58, salary=2000)], 赵五=[StreamTest.User(name=赵五, age=48, salary=4000)]}
partitioningBy

如果只有两类，使用partitioningBy会比groupingBy更有效率，按照工资是否大于2500分组

@Test
public void testPartitioningBy() {
    List<User> users = Arrays.asList(new User("张三", 19, 1000),
            new User("张三", 58, 2000),
            new User("李四", 38, 3000),
            new User("赵五", 48, 4000)
    );
    Map<Boolean, List<User>> map = users.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 2500));
    map.forEach((x, y) -> System.out.println(x + "->" + y));
}

输出结果

false->[StreamTest.User(name=张三, age=19, salary=1000), StreamTest.User(name=张三, age=58, salary=2000)]
true->[StreamTest.User(name=李四, age=38, salary=3000), StreamTest.User(name=赵五, age=48, salary=4000)]
max、min
@Test
public void testMaxAndMin() {
    String[] arr = new String[]{"b", "ab", "abc", "abcd", "abcde"};
    Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);
    Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);
}

输出结果

abcde
b
count
@Test
public void testCount(){
    String[] arr = new String[]{"b", "ab", "abc", "abcd", "abcde"};
    long count = Stream.of(arr).count();
    System.out.println(count);
}

输出结果

5
summaryStatistics

我们可以使用summaryStatistics方法获得stream中元素的各种汇总数据

@Test
public void testSummaryStatistics() {
    //计算 count, min, max, sum, and average for numbers
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    // IntSummaryStatistics stats = numbers.stream().collect(Collectors.summarizingInt(x -> x));
    IntSummaryStatistics stats = numbers
        .stream()
        .mapToInt(x -> x)
        .summaryStatistics();

    System.out.println("List中最大的数字 : " + stats.getMax());
    System.out.println("List中最小的数字 : " + stats.getMin());
    System.out.println("所有数字的总和   : " + stats.getSum());
    System.out.println("所有数字的平均值 : " + stats.getAverage());
}

输出结果

List中最大的数字 : 10
List中最小的数字 : 1
所有数字的总和   : 55
所有数字的平均值 : 5.5

短路操作

  • anyMatch：检查是否有一个元素匹配，方法参数为断言型接口
  • allMatch：检查是否匹配所有元素，方法参数为断言型接口
  • findFirst：返回第一个元素，无方法参数
  • findAny：返回当前流的任意元素，无方法参数
  • noneMatch：检查是否没有匹配所有元素，方法参数为断言型接口
anyMatch
@Test
public void testAnyMatch() {
    String[] arr = new String[]{"b", "ab", "abc", "abcd", "abcde"};
    Boolean aBoolean = Stream.of(arr).anyMatch(x -> x.startsWith("a"));
    System.out.println(aBoolean);
}

输出结果

true
findFirst
@Test
public void testFindFirst() {
    String[] arr = new String[]{"b", "ab", "abc", "abcd", "abcde"};
    String str = Stream.of(arr).parallel().filter(x -> x.length() > 3).findFirst().orElse("noghing");
    System.out.println(str);
}

输出结果

abcd
findAny
/**
 * findAny
 * 找到所有匹配的元素
 * 对并行流十分有效
 * 只要在任何片段发现了第一个匹配元素就会结束整个运算
 */
@Test
public void testFindAny() {
    String[] arr = new String[]{"b", "ab", "abc", "abcd", "abcde"};
    Optional<String> optional = Stream.of(arr).parallel().filter(x -> x.length() > 2).findAny();
    optional.ifPresent(System.out::println);
}

输出结果

abc

Optional类型

通常聚合操作会返回一个Optional类型，Optional表示一个安全的指定结果类型，所谓的安全指的是避免直接调用返回类型的null值而造成空指针异常，调用optional.ifPresent()可以判断返回值是否为空，或者直接调用ifPresent(Consumer<? super T> consumer)在结果不为空时进行消费操作；调用optional.get()获取返回值。通常的使用方式如下：

@Test
public void testOptional() {
    List<String> list = new ArrayList<String>() {
        {
            add("user1");
            add("user2");
        }
    };
    Optional<String> opt = Optional.of("user3");
    opt.ifPresent(list::add);
    list.forEach(System.out::println);
}

输出结果

user1
user2
user3

使用Optional可以在没有值时指定一个返回值，例如

@Test
public void testOptional2() {
    Integer[] arr = new Integer[]{4, 5, 6, 7, 8, 9};
    Integer result = Stream.of(arr).filter(x -> x > 9).max(Comparator.naturalOrder()).orElse(-1);
    System.out.println(result);
    Integer result1 = Stream.of(arr).filter(x -> x > 9).max(Comparator.naturalOrder()).orElseGet(() -> -1);
    System.out.println(result1);
    Integer result2 = Stream.of(arr).filter(x -> x > 9).max(Comparator.naturalOrder()).orElseThrow(RuntimeException::new);
    System.out.println(result2);
}

输出结果

-1
-1


java.lang.RuntimeException

原始类型流

在数据量比较大的情况下，将基本数据类型（int,double…）包装成相应对象流的做法是低效的，因此，我们也可以直接将数据初始化为原始类型流，在原始类型流上的操作与对象流类似，我们只需要记住两点

  1. 原始类型流的初始化

  2. 原始类型流与流对象的转换

/**
 * 原始类型流的初始化
 */
@Test
public void testRawStream1() {
    IntStream intStream = IntStream.of(1, 3);
    IntStream stream1 = IntStream.rangeClosed(0, 1);
    IntStream stream2 = IntStream.range(0, 1);
    intStream.forEach(System.out::println);
    System.out.println("包括右边界");
    stream1.forEach(System.out::println);
    System.out.println("不包括右边界");
    stream2.forEach(System.out::println);
}

输出结果

1
3
包括右边界
0
1
不包括右边界
0

流与原始类型流的转换

@Test
public void testRawStream2() {
    IntStream intStream = IntStream.of(1, 3);
    Stream<Integer> stream = intStream.boxed();
    IntStream intStream1 = stream.mapToInt(Integer::new);
    intStream1.forEach(System.out::println);
}

输出结果

1
3

并行流

可以将普通顺序执行的流转变为并行流，只需要调用顺序流的parallel() 方法即可，如Stream.iterate(1, x -> x + 1).limit(10).parallel()。

并行流的执行顺序

我们调用peek方法来瞧瞧并行流和串行流的执行顺序，peek方法顾名思义，就是追踪流内的数据，peek方法声明为Stream peek(Consumer<? super T> action);加入打印程序可以观察到通过流内数据，见如下代码：

public void peek1(int x) {
    System.out.println(Thread.currentThread().getName() + ":->peek1->" + x);
}

public void peek2(int x) {
    System.out.println(Thread.currentThread().getName() + ":->peek2->" + x);
}

public void peek3(int x) {
    System.out.println(Thread.currentThread().getName() + ":->final result->" + x);
}

/**
 * peek，监控方法
 * 串行流和并行流的执行顺序
 */
@Test
public void testPeek() {
    Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10);
    stream.peek(this::peek1).filter(x -> x > 5)
            .peek(this::peek2).filter(x -> x < 8)
            .peek(this::peek3)
            .forEach(System.out::println);
}

@Test
public void testPeekParallel() {
    Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10).parallel();
    stream.peek(this::peek1).filter(x -> x > 5)
            .peek(this::peek2).filter(x -> x < 8)
            .peek(this::peek3)
            .forEach(System.out::println);
}

testPeek方法输出结果

main:->peek1->1
main:->peek1->2
main:->peek1->3
main:->peek1->4
main:->peek1->5
main:->peek1->6
main:->peek2->6
main:->final result->6
6
main:->peek1->7
main:->peek2->7
main:->final result->7
7
main:->peek1->8
main:->peek2->8
main:->peek1->9
main:->peek2->9
main:->peek1->10
main:->peek2->10

testPeekParallel输出结果

main:->peek1->7
ForkJoinPool.commonPool-worker-9:->peek1->6
ForkJoinPool.commonPool-worker-2:->peek1->3
main:->peek2->7
ForkJoinPool.commonPool-worker-9:->peek2->6
ForkJoinPool.commonPool-worker-9:->final result->6
main:->final result->7
7
6
ForkJoinPool.commonPool-worker-13:->peek1->4
ForkJoinPool.commonPool-worker-4:->peek1->9
ForkJoinPool.commonPool-worker-11:->peek1->2
ForkJoinPool.commonPool-worker-6:->peek1->1
main:->peek1->8
main:->peek2->8
ForkJoinPool.commonPool-worker-2:->peek1->5
ForkJoinPool.commonPool-worker-4:->peek2->9
ForkJoinPool.commonPool-worker-9:->peek1->10
ForkJoinPool.commonPool-worker-9:->peek2->10

我们将stream.filter(x -> x > 5).filter(x -> x < 8).forEach(System.out::println)的过程想象成管道，我们在管道上加入的peek相当于一个阀门，透过这个阀门查看流经的数据

（1）当我们使用顺序流时，数据按照源数据的顺序依次通过管道，当一个数据被filter过滤，或者经过整个管道而输出后，第二个数据才会开始重复这一过程

（2）当我们使用并行流时，系统除了主线程外启动了6个线程（我的电脑是6核12线程）来执行处理任务，因此执行是无序的，但同一个线程内处理的数据是按顺序进行的。

sorted()、distinct()等对并行流的影响

对于并行流执行sorted()、distinct()，会使得运行时间大大增加，这个说法是错误的，测试表明不管是filter()还是distinct().sorted()，并行流都比串行流高效

/**
 * 生成一亿条0-100之间的记录
 */
@Test
public void testParallelDistinct() {
    Random random = new Random();
    List<Integer> list = Stream.generate(() -> random.nextInt(100)).limit(100000000).collect(Collectors.toList());

    long begin1 = System.currentTimeMillis();
    list.stream().filter(x -> (x > 10)).filter(x -> x < 80).count();
    long end1 = System.currentTimeMillis();
    System.out.println("串行流执行时间：" + (end1 - begin1));

    list.stream().parallel().filter(x -> (x > 10)).filter(x -> x < 80).count();
    long end2 = System.currentTimeMillis();
    System.out.println("并行流执行时间：" + (end2 - end1));

    long beginDis = System.currentTimeMillis();
    list.stream().filter(x -> (x > 10)).filter(x -> x < 80).distinct().sorted().count();
    long end1Dis = System.currentTimeMillis();
    System.out.println("串行流执行排序时间：" + (end1Dis - beginDis));
    list.stream().parallel().filter(x -> (x > 10)).filter(x -> x < 80).distinct().sorted().count();
    long end2Dis = System.currentTimeMillis();
    System.out.println("并行流执行排序时间：" + (end2Dis - end1Dis));
}

输出结果

串行流执行时间：2009
并行流执行时间：514
串行流执行排序时间：2023
并行流执行排序时间：699

总结

Java8中的lambda表达式可能一开始用的时候还不是很熟悉，但是只要熟悉了，你会发现非常的好用，而且lambda表达式结合stream API对集合的处理非常方便，在平常项目中可以非常的省时间，提高写代码的效率。

Stream 详解

Stream 中的常用方法：

方法参数作用
filterPredicate<? super T> predicate过滤
mapFunction<? super T, ? extends R> mapper转换
flatMapFunction<? super T, ? extends Stream<? extends R>> mapper转换+扁平化
distinct去重
sortedComparator<? super T> comparator排序
limitlong n限量
skiplong n跳过
forEachConsumer<? super T> action遍历
anyMatch/allMatchPredicate<? super T> predicate匹配

Collect 详解

Collect 中的常用方法：

方法返回类型作用
toListList转成一个 List
toSetSet转成一个 Set
toMapMap<K,U>转成一个 Map
joiningString拼接所有元素，返回一个 String
countingLong返回元素个数
minByOptional选出最小元素
maxByOptional选出最大元素
averagingIntDouble求平均值
summingIntInteger求和
groupingByMap<K, List>对元素进行分组
partitioningByMap<Boolean, List>将元素分成 true 和 false 两个分组
ThinkWon
关注
  • 39
    点赞
  • 踩
  • 133
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
678.676.JAVA基础教程_动态代理与Java8新特性-Stream的实例化(678).rar
11-09
678.676.JAVA基础教程_动态代理与Java8新特性-Stream的实例化(678).rar
java8新特性-最新
12-18
此文件为某知名培训机构的讲义，内容是 java8新特性 Lambda表达式 Stream流 内容比较新颖。
Java中的Stream流库
LostRed的博客
03-11 262
这里写目录标题1. 什么是流1.1 概念1.2 特点2. 流的操作步骤3. 流的创建3. 流的转换3.1 filter、map、flatMap方法3.2 抽取子流和连接流4. 流的终结4.1 min和max4.2 findFirst和findAny4.3 anyMatch, allMatch和noneMatch5. Optional类型5.1 如何使用Optional值5.2 不适合使用Optional值的方式5.3 创建Optional值5.4 用flatMap来构建Optional值的函数 1. 什么是
java8之stream
jason_xiaojie_liu的博客
01-09 331
lambda表达式是stream的基础，初学者建议先学习lambda表达式，http://www.cnblogs.com/andywithu/p/7357069.html 1.初识stream 先来一个总纲：   东西就是这么多啦，stream是java8中加入的一个非常实用的功能，最初看时以为是io中的流（其实一点关系都没有），让我们先来看一个小例子感受一下： @Before...
JAVA SE 8 的流库-1.14并行流
z036548的博客
11-19 204
1.14 并行流 流使得并行处理块操作变得很容易。这个过程几乎是自动的，但是需要遵守一些规则。 首先，必须有一个并行流。可以用Collection.parallelStream()方法从任何集合中获取一个并行流： 在这里插入代码片 而且，parallel方法可以将任意顺序流转换为并行流。 在这里插入代码片 只要在终结方法执行时，流处于并行模式，那么所有的中间流操作都将被并行化。 当流操作并行...
Stream流sorted方法,reversed注意事项
weixin_43999284的博客
12-16 5988
stream流多个条件倒序排序时注意的点
java8-常用stream操作(1)
weixin_43087333的博客
08-18 755
前言 java8的Stream 流式操作，用于对集合进行投影、转换、过滤、排序、去重等，更进一步地说，这些操作能链式串联在一起使用，类似于 SQL 语句，可以大大简化代码。下面我就将平时常用的一些stream操作做一些汇总。 通过 IntStream 构造基本类型的流 //在java8之前，遍历0-99的基本操作 for(int i = 0;i<100;i++){ System.out.println("i:"+i); }
Java Stream类常见用法
sc179的博客
08-31 2889
Java Stream类常见用法
stream流倒序排序_java8 stream多字段排序
java_2017_csdn的博客
09-06 9999
stream流倒序排序_java8 stream多字段排序 List list; 代表某集合 //返回 对象集合以类属性一升序排序 list.stream().sorted(Comparator.comparing(类::属性一)); //返回 对象集合以类属性一降序排序 注意两种写法 list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序 list.stream().sorted(Com
stream流排序
热门推荐
qq_36763236的博客
12-21 2万+
List 倒序排列 List<Double> salesData = new ArrayList<>(); Collections.reverse(salesData); java8 stream多字段排序 List<类> rankList = new ArrayList<>(); 代表某个集合 //返回 对象集合以类属性一升序排序 rankList.stream().sorted(Comparator.comparing(类::属性一));
677.675.JAVA基础教程_动态代理与Java8新特性-Stream API的概述(677).rar
11-09
677.675.JAVA基础教程_动态代理与Java8新特性-Stream API的概述(677).rar
684.682.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：收集(684).rar
11-09
684.682.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：收集(684).rar
682.680.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：匹配(682).rar
11-09
682.680.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：匹配(682).rar
683.681.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：归约(683).rar
11-09
683.681.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：归约(683).rar
681.679.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：排序(681).rar
11-09
681.679.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：排序(681).rar
680.678.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：映射(680).rar
11-09
680.678.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：映射(680).rar
679.677.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：筛选(679).rar
11-09
679.677.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：筛选(679).rar
Java8新特性Stream流实例详解
08-29
Stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。这篇文章主要介绍了Java8新特性Stream流的相关资料，需要的朋友参考下吧
java8新特性Lambda与stream视频教程-文档和代码.rar
10-25
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以...
java8新特性stream
最新发布
05-19
Java 8引入了一种新的处理集合的方式，称为Stream API。Stream API可以让开发者以声明式的方式处理集合中的数据，从而更加简洁、灵活和可读。下面是一些Java 8 Stream API的新特性： 1. 可以对集合中的元素进行过滤、映射、排序等操作，而无需编写循环和条件语句。 2. Stream API支持延迟计算，只有在需要时才会进行计算，可以提高效率。 3. 可以使用并行流（parallel stream）来进行并行处理，从而更快地完成处理任务。 4. Stream API支持多种操作，包括中间操作（intermediate operation）和终端操作（terminal operation），可以根据需要进行组合。 5. Stream API提供了很多内置函数，可以方便地进行常用操作，如计数、求和、最大值、最小值等。 6. Stream API还可以与Lambda表达式结合使用，从而更加方便地编写函数式代码。 总之，Java 8 Stream API是一个非常强大和实用的工具，可以极大地简化集合处理的代码，提高代码的可读性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值