关于stream:Java8-Stream-提高编码效率早点下班

11次阅读

共计 4727 个字符，预计需要花费 12 分钟才能阅读完成。

编程中操作汇合数据是十分频繁的，应用 Java8 中的 Stream 对汇合解决，联合 Lambda 函数式编程能极大的简化代码，正当的应用 Stream 能进步代码可读性，另一方面从 Java8 面世以来 Stream API 通过了有数我的项目的实际考验，其稳定性和性能自不必说，网上有很多相干的性能测试案例能够查阅参考，如果有人对你说：Lambda 可读性不好，保护老本低等一些问题，你大可释怀，请肯定看下最初的留神点

Stream 的创立形式比拟多，接下来介绍几种罕用的形式，以下 Lists 应用的 google guava 的 API，间接上代码：

// 形式 1：Stream.of 以及其余的静态方法，测试常应用
Stream<String> stream1 = Stream.of("A", "B");
// 形式 2：Collection 形式，常见如（List、Set）Stream<String> stream2 = Lists.newArrayList("A", "B").stream();
Stream<String> stream3 = Sets.newHashSet("A", "B").stream();
// 形式 3：数组形式
Stream<String> stream4 = Arrays.stream(new String[]{"A", "B"});
// 形式 4：通过 API 接口创立，文件 API 等
Stream<String> stream5 = Files.lines(Paths.get("/file.text"));
// 形式 5：创立根本数据类型对应的 Stream，如：IntStream、LongStream、DoubleStream
IntStream stream6 = Arrays.stream(new int[] {1, 2, 3});
// 形式 6：通过 Stream.builder 创立
Stream<Object> stream7 = Stream.builder().add("A").build();

以上创立形式 形式 2 、形式 3 比拟罕用，其中形式 3 也能够应用 parallelStream 创立并行流，其余的形式能够通过 parallel 办法转换为并行流，在数据量较大时进步数据处理效率，如下：

// 间接应用 parallelStream 创立
Stream<String> stream1 = Lists.newArrayList("A", "B").parallelStream();
// 应用 parallel 转化一般流为并行流
Stream<String> stream2 = Arrays.stream(new String[]{"A", "B"}).parallel();

Stream.map
将原数据处理后生成新的数据，其中 mapToInt、mapToLong、mapToDouble 办法可间接转换为 IntStream、LongStream、DoubleStream（用的比拟少，大家可自行查找）

// 原数据增加后缀 -N
List<String> result1 = Lists.newArrayList("A")
        .stream().map(item -> item + "-N").collect(Collectors.toList());
// 原字符串转化为数组
List<String[]> result2 = Lists.newArrayList("A")
        .stream().map(item -> new String[]{item}).collect(Collectors.toList());

Stream.flatMap
合并多个 Stream 为一个 Stream，常常用在合并多个 List 数据

List<String> result = Lists.newArrayList(Lists.newArrayList("A"),
        Lists.newArrayList("B")
).stream().flatMap(Collection::stream).collect(Collectors.toList());

Stream.filter
元素过滤，可代替循环中的 if 判断条件，参数为逻辑表达式

List<String> result = Lists.newArrayList("A", "B")
        .stream().filter("A"::equals).collect(Collectors.toList());

Stream.distinct
元素去反复，个别用在简略数据类型，如果是对象能够利用 TreeSet 去重示例如下

// 简略数据类型去重
List<String> result1 = Lists.newArrayList("A", "A", "B")
        .stream().distinct().collect(Collectors.toList());
// 对象数据去重
List<Demo> result2 = Lists.newArrayList(new Demo()).stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
                new TreeSet<>(comparing(Demo::getName))), ArrayList::new)
);

@Data
class Demo {
    private String name;
    private String age;
}

Stream.peek
只进行数据处理，不扭转原数据类型，和 map 的区别就是 peek 承受一个无返回值的操作，个别用于批改对象外部元素

List<Demo> result = Lists.newArrayList(new Demo())
        .stream().peek(item -> item.setName("A")).collect(Collectors.toList());

Stream.sorted
对数据进行排序，反对正序和倒序，并且反对对象类型数据排序

// 简略数据类型排序
List<String> result1 = Lists.newArrayList("A", "B")
        .stream().sorted().collect(Collectors.toList());
// 对象类型依据某个属性排序，默认正序，倒序应用 reversed 办法
List<Demo> result2 = Lists.newArrayList(new Demo())
        .stream().sorted(Comparator.comparing(Demo::getName).reversed()).collect(Collectors.toList());

Stream.limit
限度最终输入数据的数量，截取流中的元素，默认不进行截取

List<String> result1 = Lists.newArrayList("A", "B")
        .stream().limit(1).collect(Collectors.toList());

Stream.skip
跳过前多少个元素，和 limit 相似，limit 是截取流达到限度数量立即返回流

List<String> result = Lists.newArrayList("A", "B")
        .stream().skip(1).collect(Collectors.toList());

collect
收集流数据，罕用：Collectors.toList（收集为 List）、Collectors.joining（收集拼接为 String）

// 收集数据为 List
List<String> result1 = Lists.newArrayList("A", "B").stream().collect(Collectors.toList());
// 收集数据为 String，默认无分隔符，能够应用带参数的 joining 办法指定分隔符
String result2 = Lists.newArrayList("A", "B").stream().collect(Collectors.joining());

reduce
数据聚合为一个值，数据转化为单值后，计算得出一个最终值，这里已累加为例

BigDecimal result = Lists.newArrayList(BigDecimal.valueOf(1), BigDecimal.valueOf(2)).stream().reduce(BigDecimal.ZERO, BigDecimal::add);

allMatch、anyMatch、noneMatch

// 所有元素都大于 1，返回 true
boolean result1 = Lists.newArrayList(1, 2, 3, 4).stream().allMatch(item -> item > 1);
// 任意元素大于 1，返回 true
boolean result2 = Lists.newArrayList(1, 2, 3, 4).stream().anyMatch(item -> item > 1);
// 没有元素大于 1，返回 true
boolean result3 = Lists.newArrayList(1, 2, 3, 4).stream().noneMatch(item -> item > 1);

count
统计数据数量值

long result1 = Lists.newArrayList(1, 2, 3, 4).stream().count();

findAny、findFirst
如果存在数据，都返回一条，区别是在并行处理中，findAny 匹配到数据就返回，findFirst 须要等所有数据处理实现返回第一条，所以在并行处理中 findAny 效率更高

// 获取任意一个及时返回
Integer result1 = Lists.newArrayList(1, 2, 3, 4).stream().findAny().get();
// 所有元素执行实现返回第一条
Integer result12= Lists.newArrayList(1, 2, 3, 4).parallelStream().findFirst().get();

forEach、forEachOrdered
遍历所有元素，比方输入操作，有了 forEach 为什么还须要 forEachOrdered 呢，次要是在并行执行中，元素执行是没有程序的，forEachOrdered 能将后果依照程序输入

// 输入所有元素
Lists.newArrayList(1, 2, 3, 4).stream().forEach(System.out::println);
// 程序输入
Lists.newArrayList(1, 2, 3, 4).parallelStream().forEachOrdered(System.out::println);

max、min
获取流中元素最大和最小的值，以下举例最大值得获取，最小值同理

// 简略数据类型
Integer result = Lists.newArrayList(1, 2, 3, 4).stream().max(Integer::compare).get();
// 比拟对象中的属性，获取最大的记录
Demo result = Lists.newArrayList(new Demo()).stream().max(comparing(Demo::getAge)).get();

在应用并行流进行解决时，肯定须要收集最终数据，否则可能会失落数据，比方应用 collect 或者 reduce 收集数据，也就是说应用了 collect 和 reduce 能力应用 parallelStream，此时整个流解决是线程平安的

正文完