Java1.8之Stream流基本使用

Java Stream流使用分享

  • 前言
  • 基础
  • 实战
    • MockData
    • 中间操作
      • filter 过滤
      • map 类型转换
      • limit 数据截取
      • sorted 数据排序
      • distinct 去重
    • 终端操作
      • count 数据计数统计
      • allMatch anyMatch 条件返回
      • collect 数据规约
  • 总结

前言

Java1.8中引入了流的概念,具体实现是java.util.stream.Stream接口,流的性能是高效的,在多核CPU中,可以充分的的利用CPU资源,代码写起来也比常规的写法更简洁,在实际开发中,用得也比较多

我总结了一下Stream流的基本用法和常用方法,让我们来感受一下吧

基础

在使用流之前,需要准备三件事情:

  • 数据源
  • 中间操作链:用来形成流水线
  • 终端操作:用来生成最终结果

中间操作

操作 返回类型 说明 使用场景
filter Stream<T> 返回一个由与此流匹配的元素组成的流 过滤元素
map Stream<R> 返回由应用给定结果组成的流 类型转换
limit Stream<T> 返回一个被截断指定长度的流 数据截取
sorted Stream<T> 返回由该流的元素组成的流,根据自然顺序排序 如果此流的元素不是Comparable,可能会引起ClassCastException异常 数据排序
distinct Stream<T> 返回由不同元素组成的流 数据去重

终端操作

操作 返回类型 说明 使用场景
forEach void 消费流中的每个元素并对其应用Lambda 遍历元素
count long 返回流中元素的个数 统计数量
collect <R> R 把流规约成一个集合,可以是List、Map、Integer 数据归约
anyMatch boolean 流中元素任意一个满足判断条件 数据判断
allMatch boolean 流中元素全部满足判断条件 数据判断

实战

MockData

在实际开发中,我们使用的更多的是DTO,所以新建一个类,再造些数据

@Data
@AllArgsConstructor
static class DTO {
    private String name;

    private Integer age;
    @Override
    public String toString() {
        return "(name=" + this.name + ", age=" + this.age + ")";
    }
}

List<DTO> list = Arrays.asList(new DTO("苹果", 20), new DTO("香蕉", 35), new DTO("橘子", 15), new DTO("芒果", 50));   

中间操作

filter 过滤

Api:

// 返回 predicate(过滤条件) 为True的元素
Stream<T> filter(Predicate<? super T> predicate);

示例

// 过滤价格大于20的水果
list.stream().filter(o -> o.getPrice() > 20).forEach(System.out::println);       

输出如下:

(name=香蕉, price=35)
(name=芒果, price=50

map 类型转换

Api:

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

IntStream mapToInt(ToIntFunction<? super T> mapper);

LongStream mapToLong(ToLongFunction<? super T> mapper);

DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

类型转换的Api很多,这里只用map举例,其他Api用法大同小异,当我们要把类中的price转换成String或者其他类型的时候,可以这样

// 类型转换map(转换过程,需要有return) 将price转换成Double类型,并只返回Double类型的age
List<Double> collect = list.stream().map(o -> Double.valueOf(o.getPrice())).collect(Collectors.toList());
System.out.println(collect);

输出如下

[20.0, 35.0, 15.0, 50.0]

limit 数据截取

Api:

Stream<T> limit(long maxSize);

maxSize表示返回元素的最大数量

list.stream().limit(2).forEach(System.out::println);

输出如下

(name=苹果, price=20)
(name=香蕉, price=35)

sorted 数据排序

Api:

// 原生排序  如果T没有实现Comparable,会引起ClassCastException异常
Stream<T> sorted();

// 可以自定义排序规则  扩展性高
Stream<T> sorted(Comparator<? super T> comparator);

先来看看原生排序,会发生异常:
java.lang.ClassCastException: xxxxxxx cannot be cast to java.lang.Comparable

// 排序
List<DTO> collect1 = list.stream().sorted().collect(Collectors.toList());
System.out.println(collect1);

输出如下

Exception in thread "main" java.lang.ClassCastException: com.steam.T_ForeachSteam$DTO cannot be cast to java.lang.Comparable
	at java.util.Comparators$NaturalOrderComparator.compare(Comparators.java:47)
	at java.util.TimSort.countRunAndMakeAscending(TimSort.java:355)
	at java.util.TimSort.sort(TimSort.java:220)
	at java.util.Arrays.sort(Arrays.java:1512)
	at java.util.stream.SortedOps$SizedRefSortingSink.end(SortedOps.java:348)
	at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482)
	at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
	at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
	at com.steam.T_ForeachSteam.main(T_ForeachSteam.java:35)

自定义排序

list.stream().sorted(Comparator.comparing(DTO::getPrice)).forEach(System.out::println);

输出如下:

(name=橘子, price=15)
(name=苹果, price=20)
(name=香蕉, price=35)
(name=芒果, price=50)

倒序

list.stream().sorted(Comparator.comparing(DTO::getPrice).reversed()).forEach(System.out::println);

输出如下:

(name=芒果, price=50)
(name=香蕉, price=35)
(name=苹果, price=20)
(name=橘子, price=15)

distinct 去重

Api:

// 底层是一个HashSet的实现
Stream<T> distinct()
List<Integer> distinctList = Arrays.asList(10, 11, 10);
distinctList.stream().distinct().forEach(o -> System.out.print(o + " "));

输出如下

10 11

终端操作

count 数据计数统计

Api:

long count();
List<String> anyMatchList = Arrays.asList("1","2","3","4","5");
long count = anyMatchList.stream().count();
System.out.println(count);

输出如下

5

allMatch anyMatch 条件返回

Api:

boolean allMatch(Predicate<? super T> predicate);
List<String> addList = new ArrayList<>();
List<String> anyMatchList = Arrays.asList("1","2","3","4","5");
// 返回值可以理解为是否遍历了所有元素
boolean b = anyMatchList.stream().allMatch(o -> {
    addList.add(o);
    // 为false时返回
    return addList.size() < 2;
});
System.out.println(addList.toString() + b);

输出如下

[1, 2]false

Api:

boolean allMatch(Predicate<? super T> predicate);
List<String> addList1 = new ArrayList<>();
// 返回值可以理解为是否有一个元素满足返回条件
boolean any = anyMatchList.stream().anyMatch(o -> {
    addList1.add(o);
    // 为true时返回
    return addList1.size() < 2;
});
System.out.println(addList1.toString() + any);

输出如下

[1]true

collect 数据规约

Api:

<R, A> R collect(Collector<? super T, A, R> collector);

<R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);

使用

 List<DTO> list = Arrays.asList(new DTO("苹果", 20), new DTO("香蕉", 35),
         new DTO("菠萝", 20), new DTO("水蜜桃", 35),
         new DTO("橘子", 15), new DTO("芒果", 50));
 // 根据price分组
 Map<Integer, List<DTO>> collect = list.stream().collect(Collectors.groupingBy(DTO::getPrice));
 System.out.println(JSON.toJSONString(collect));

 // 转换成set集合
 System.out.println(Stream.of("a", "b", "c","a").collect(Collectors.toSet()));
 
 // 转换成map
 Map<String, String> collect1 = Stream.of("a", "b", "c", "a").collect(Collectors.toMap(x -> x, x -> x + x,(oldVal, newVal) -> newVal));
 collect1.forEach((k,v) -> System.out.println(k + ":" + v));

输出如下

{50:[{"name":"芒果","price":50}],35:[{"name":"香蕉","price":35},{"name":"水蜜桃","price":35}],20:[{"name":"苹果","price":20},{"name":"菠萝","price":20}],15:[{"name":"橘子","price":15}]}
[a, b, c]
a:aa
b:bb
c:cc

总结

Java Stream Api繁多,需要读者手动写代码感受一下。
笔者水平有限,文中有不正之处还请各位不吝指出,Stream涉及知识面广,笔者一时也无法全面叙出,文章会不定时更新和巩固,欢迎给我留言,我会在第一时间回复

你可能感兴趣的:(java,java,stream,lambda)