Java Stream API 操作完全攻略：让你的代码更加出色 (三)-六虎

前言

Java Stream 是一种强大的数据处理工具，能够协助开发人员快速高效地处理和转化数据流。运用 Stream 操作能够大大简化代码，使其更具可读性和可维护性，然后前进开发功率。本文将为您介绍 Java Stream 操作的一切方面，包括 groupingBy、groupingBy、joining、mapping 等操作，让你的代码行云流水，更加高雅。

groupingBy()：依照指定条件对 Stream 中的元素进行分组。
partitioningBy()：依照指定条件对 Stream 中的元素进行分区。
joining()：将 Stream 中的元素连接成一个字符串。
mapping()：依据指定的 Function 对 Stream 中的元素进行映射，并回来一个新的 Stream。
flatMapping()：将每个元素映射为一个 Stream，然后将这些 Stream 连接成一个 Stream。
iterating()：运用指定的种子值创立一个 Stream，并顺次对每个元素进行指定的操作。
empty()：回来一个空的 Stream。
of()：依据指定的元素创立一个 Stream。
concat()：将多个 Stream 连接成一个 Stream。
unordered()：回来一个无序的 Stream。

示例

1. 运用 groupingBy() 依照字符串长度对字符串列表进行分组

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class GroupingByExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("hello", "world", "java", "stream");
        Map<Integer, List<String>> result = stringList.stream()
                .collect(Collectors.groupingBy(String::length));
        System.out.println(result);
    }
}

输出成果：

{5=[hello, world], 4=[java], 6=[stream]}

2.运用 partitioningBy() 将数字列表依照是否为偶数进行分区

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class PartitioningByExample {
    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Map<Boolean, List<Integer>> result = numberList.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        System.out.println(result);
    }
}

输出成果：

{false=[1, 3, 5, 7, 9], true=[2, 4, 6, 8, 10]}

3.运用 joining() 将字符串列表中的元素用逗号连接成一个字符串

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class JoiningByExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("hello", "world", "java", "stream");
        String result = stringList.stream()
                .collect(Collectors.joining(","));
        System.out.println(result);
    }
}

输出成果：

hello,world,java,stream

4.运用 mapping() 将字符串列表中的元素转化为大写字母

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class MappingByExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("hello", "world", "java", "stream");
        List<String> result = stringList.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(result);
    }
}

输出成果：

[HELLO, WORLD, JAVA, STREAM]

5.运用 flatMapping() 将嵌套的字符串列表展平为一个字符串列表

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class FlatMappingByExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
                Arrays.asList("hello", "world"),
                Arrays.asList("hello","java", "stream"));
        List<String> result = nestedList.stream()
                .flatMap(List::stream)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(result);
    }
}

输出成果：

[hello, world, java, stream]

6.运用 iterating() 生成斐波那契数列前 10 项

代码示例：

import java.util.stream.Stream;
public class IteratingByExample {
    public static void main(String[] args) {
        Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
                .limit(10)
                .map(t -> t[0])
                .forEach(System.out::println);
    }
}

输出成果：

7.运用 empty() 运用空的 Stream

代码示例：

import java.util.stream.Stream;
public class EmptyStreamExample {
    public static void main(String[] args) {
        Stream<String> emptyStream = Stream.empty();
        System.out.println(emptyStream.count());
    }
}

输出成果：

8.运用 of() 创立包含一些字符串的 Stream

代码示例：

import java.util.stream.Stream;
public class OfStreamExample {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.of("hello", "world", "java", "stream");
        stringStream.forEach(System.out::println);
    }
}

输出成果：

hello
world
java
stream

9.运用 concat() 将两个字符串列表合并为一个列表

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class ConcatStreamExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("hello", "world");
        List<String> list2 = Arrays.asList("java", "stream");
        Stream<String> stream1 = list1.stream();
        Stream<String> stream2 = list2.stream();
        List<String> result = Stream.concat(stream1, stream2)
                .collect(Collectors.toList());
        System.out.println(result);
    }
}

输出成果：

[hello, world, java, stream]

10.运用 unordered() 对数字列表进行排序后，运用 unordered()回来一个无序的 Stream

代码示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class UnorderedStreamExample {
    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(1, 3, 2, 4, 10, 6, 8, 7, 9, 6);
        List<Integer> result = numberList.stream()
                .sorted()
                .unordered()
                .collect(Collectors.toList());
        System.out.println(result);
    }
}

输出成果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

来个小坑

感谢大佬看到这儿，假如你看完觉得没问题，那么你需求反思一下了哦。好了咱们能够在细心地看看，示例10.unordered()的代码。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class UnorderedStreamExample {
    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(1, 3, 2, 4, 10, 6, 8, 7, 9, 6);
        List<Integer> result = numberList.stream()
                .sorted()
                .unordered()
                .collect(Collectors.toList());
        System.out.println(result);
    }
}

输出成果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

履行进程剖析，首要输入了一个无序的流，然后运用sorted()对流进行排序，然后在运用unordered()，去除流的有序束缚。然后输出为List，再进行打印出来。按理来说，输出的次序应该是一个无序的，而不是有序的。

解答

unordered()操作不会履行任何操作来显式地对流进行排序。它的作用是消除了流有必要保持有序的束缚，然后允许后续操作运用不用考虑排序的优化。

关于次序流，次序的存在与否不会影响性能，只影响确定性。假如流是次序的，则在相同的源上重复履行相同的流管道将发生相同的成果;假如对错次序流，重复履行可能会发生不同的成果。

unordered()操作，是消除了流有必要保持有序的束缚。并不会改动，流原有的次序。关于并行流，放宽排序束缚有时能够完成更高效的履行。在流有序时, 但用户不特别关怀该次序的情况下，运用 unordered() 明确地对流进行去除有序束缚能够改进某些有状态或终端操作的并行性能。

参考

segmentfault.com/q/101000001…

结束

假如觉得对你有协助，能够多多评论，多多点赞哦，也能够到我的主页看看，说不定有你喜欢的文章，也能够随手点个重视哦，谢谢。

我是不一样的科技宅，每天前进一点点，体验不一样的日子。咱们下期见！

Java Stream API 操作完全攻略：让你的代码更加出色 (三)

前言

示例

1. 运用 groupingBy() 依照字符串长度对字符串列表进行分组

2.运用 partitioningBy() 将数字列表依照是否为偶数进行分区

3.运用 joining() 将字符串列表中的元素用逗号连接成一个字符串

4.运用 mapping() 将字符串列表中的元素转化为大写字母

5.运用 flatMapping() 将嵌套的字符串列表展平为一个字符串列表

6.运用 iterating() 生成斐波那契数列前 10 项

7.运用 empty() 运用空的 Stream

8.运用 of() 创立包含一些字符串的 Stream

9.运用 concat() 将两个字符串列表合并为一个列表

10.运用 unordered() 对数字列表进行排序后，运用 unordered()回来一个无序的 Stream

来个小坑

解答

参考

结束

相关文章

Android音视频一：AudioPolicyService启动

Twitter 是如何落地故障测试的

火山引擎DataTester：如何做A/B实验的假设检验

【C/C++动态内存 or 柔性数组】——对动态内存分配以及柔性数组的概念进行详细解读（张三 or 李四）

作者信息