前言
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=, 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,stream4. 应用 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);
}
}输入后果：
0
1
1
2
3
5
8
13
21
347. 应用 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());
}
}输入后果：
08. 应用 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
stream9. 应用 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() 明确地对流进行去除有序束缚能够改善某些有状态或终端操作的并行性能。
参考
https://segmentfault.com/q/1010000017969473
结尾
如果感觉对你有帮忙，能够多多评论，多多点赞哦，也能够到我的主页看看，说不定有你喜爱的文章，也能够顺手点个关注哦，谢谢。
我是不一样的科技宅，每天提高一点点，体验不一样的生存。咱们下期见！