Java8新特性stream

Java8新特性stream

概念

Stream是Java8 API的新成员,它允许以声明性方式处理数据集合

特点

(1)代码简洁:函数式编程写出的代码简洁且意图明确,使用stream接口让你从此告别for循环。

(2)多核友好:Java函数式编程使得编写并行程序从未如此简单,你需要的全部就是调用一下方法。

流程

1)第一步:把集合转换为流stream
2)第二步:操作stream流stream流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作(terminal operation)得到前面处理的结果

操作符

两种:中间操作符、终止操作符

 filter   | 用于通过设置的条件过滤出元素                                 List<String> strings = Arrays.asList("abc", "", "bc","efg", "abcd","", "jkl");
 List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); |
 distinct | 返回一个元素各异(根据流所生成元素的hashCode和equals方法实现)的流。 | List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
 numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println); |
limit    | 会返回一个不超过给定长度的流。                            | List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> limited = strings.stream().limit(3).collect(Collectors.toList()); |
| skip     | 返回一个扔掉了前n个元素的流。                                | List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> skiped = strings.stream().skip(3).collect(Collectors.toList()); 
| map      | 接受一个函数作为参数。这个函数会被应用到每个元素上,并将其映射成一个新的元素(使用映射一词,是因为它和转换类似,但其中的细微差别在于它是“创建一个新版本”而不是去“修改”)。 | List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList()); |
| flatMap  | 使用flatMap方法的效果是,各个数组并不是分别映射成一个流,而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来,即扁平化为一个流。 | List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
Stream<Character> flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString); |
| sorted   | 返回排序后的流                                               | List<String> strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
List<String> sorted1 = strings1.stream().sorted().collect(Collectors.toList()); |
Map、flatMap区别

map:对流中每一个元素进行处理
flatMap:流扁平化,让你把一个流中的“每个值”都换成另一个流,然后把所有的流连接起来成为一个流
总结:map是对一级元素进行操作,flatmap是对二级元素操作。

本质区别:map返回一个值;flatmap返回一个流,多个值。
应用场景:map对集合中每个元素加工,返回加工后结果;flatmap对集合中每个元素加工后,做扁平化处理后(拆分层级,放到同一层)然后返回

终止操作符

1)anyMatch

java
> /**
>  * 功能描述 : 判断集合中是否至少存在一个元素满足条件
>  * @return : void
>  */
>@Test
 public void anyMatch(){
     List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
     boolean b = strings.stream().anyMatch(s -> s == "abc");
    out.println(b);
 }

2)allMatch


> ```java
> /**
>  * 功能描述 : 判断集合中是否所有元素都满足条件
>  * @return : void
>  */
 @Test
 public void allMatch(){
     List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
     boolean b = strings.stream().allMatch(s -> s == "abc");
     out.println(b);
 }

3)noneMatch

/**
>  * 功能描述 : 判断集合中是否所有元素都不满足条件
>  * @return : void
>  */
 @Test
 public void noneMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
     boolean b = strings.stream().noneMatch(s -> s == "abc");
     out.println(b);
 }

4)findAny

java
> /**
>  * 功能描述 : 返回当前流中任意元素
>  * @return : void
>  */
> @Test
 public void findAny(){
     List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> any = strings.stream().findAny();
    if(any.isPresent()) out.println(any.get());
 }

5)findFirst

java
> /**
>  * 功能描述 : 返回当前流中第一个元素
>  * @return : void
>  */
 @Test
 public void findFirst(){
     List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
     Optional<String> first = strings.stream().findFirst();
     if(first.isPresent()) out.println(first.get());
 }

6)forEach java

/**
>  * 功能描述 : 遍历流
>  * @return : void
>  */
 @Test
 public void foreach(){
     List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
     strings.stream().forEach(s -> out.println(s));
 }

7)collect

/**
>  * 功能描述 : 流转换为其他形式
>  * @return : void
>  */
 @Test
 public void collect(){
     List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
     Set<String> set = strings.stream().collect(Collectors.toSet());
     List<String> list = strings.stream().collect(Collectors.toList());
     Map<String, String> map = strings.stream().collect(Collectors.toMap(v -v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
     out.println(set);
     out.println(list);
     out.println(map);
 }

8)reduce

@Test
 public void reduce(){
     List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
     //reduce方法一
     Optional<String> reduce1 = strings.stream().reduce((acc,item) -> {return acc+item;});
     //reduce方法二
     String reduce2 = strings.stream().reduce("itcast", (acc, item) -> {
     	return acc + item;
     });
     //reduce方法三
     ArrayList<String> reduce3 = strings.stream().reduce(
         new ArrayList<String>(),
    		new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
     		@Override
     		public ArrayList<String> apply(ArrayList<String> acc, String item) {
     			acc.add(item);
     			return acc;
     		}
     	}, 
         new BinaryOperator<ArrayList<String>>() {
    			@Override
     		public ArrayList<String> apply(ArrayList<String> acc, ArrayList<String> item) {
     		return acc;
     		}
     	}
     );
     if(reduce1.isPresent())out.println(reduce1.get());
     out.println(reduce2);
     out.println(reduce3);
 }

9)count

java
> /**
> * 功能描述 : 返回流中元素总数
> * @return : void
> */
 @Test
 public void count(){
     List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
     long count = strings.stream().count();
     out.println(count);
 }
  • 1
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值