JAVA-基础(Stream流)

2019-08-16 09:33:34来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

JAVA-基础(Stream流)

JAVA-基础(Stream流)

说起stream流大家的第一反应是io,但是实际上谁规定流一定是存在io包里呢?在java8中得益于Lambda表达式的函数式编程,引入了一个全新的概念,stream。

1.优势?

在java8之前我们遍历集合大概就是增强for循环,如果我们想在这个集合里增加一些添加来搜索集合的一些东西,我们会发现代码会变得非常杂乱无章,但是我们现在用stream就会很优雅的解决这个问题。

代码:

  1. 首先筛选所有姓茂的人;

  2. 然后筛选名字有三个字的人;

  3. 最后进行对结果进行打印输出。

 1 package cn.fan;
 2 ?
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 ?
 6 public class Stream1 {
 7     public static void main(String[] args) {
 8         //第一条件:筛选姓茂的
 9         //第二条件:筛选名字三个字的
10         //再进行打印
11         List<String> list = new ArrayList<>();
12         list.add("茂小喵");
13         list.add("罗三炮");
14         list.add("阿龟哥");
15         list.add("范小饭");
16         List<String> maoList = new ArrayList<>();
17         for (String name : list) {
18             if (name.startsWith("茂")) {
19                 maoList.add(name);
20             }
21         }
22 ?
23         List<String> shortList = new ArrayList<>();
24         for (String name : maoList) {
25             if (name.length() == 3) {
26                 shortList.add(name);
27             }
28         }
29 ?
30         for (String name : shortList) {
31             System.out.println(name);
32         }
33 ?
34     }
35 }
View Code

那么现在有一种更加优雅的做法:

 1 package cn.fan;
 2 ?
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 ?
 6 public class Stream2 {
 7     public static void main(String[] args) {
 8         List<String> list = new ArrayList<>();
 9         list.add("茂小喵");
10         list.add("罗三炮");
11         list.add("阿龟哥");
12         list.add("范小饭");
13 ?
14         list.stream()
15                 .filter(s->s.startsWith("茂"))
16                 .filter(s->s.length()==3)
17                 .forEach(System.out::println);
18     }
19 }
View Code

Stream(流)是一个来自数据源的元素队列。 元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。 数据源 流的来源。 可以是集合,数组 等。

“Stream流”其实是一个集合元素的函数模型,它并不是集合,也不是数据结构,其本身并不存储任何 元素(或其地址值)。

2.获取stream的两种方法?

default Stream<E> stream()

static <T> Stream<T> of(T... values)

 1 package com.itheima.demo02.Stream;
 2 ?
 3 import java.util.*;
 4 import java.util.stream.Stream;
 5 ?
 6 /*
 7     java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。(这并不是一个函数式接口。)
 8     获取一个流非常简单,有以下几种常用的方式:
 9         - 所有的Collection集合都可以通过stream默认方法获取流;
10             default Stream<E> stream()
11         - Stream接口的静态方法of可以获取数组对应的流。
12             static <T> Stream<T> of(T... values)
13             参数是一个可变参数,那么我们就可以传递一个数组
14  */
15 public class Demo01GetStream {
16     public static void main(String[] args) {
17         //把集合转换为Stream流
18         List<String> list = new ArrayList<>();
19         Stream<String> stream1 = list.stream();  Set<String> set = new HashSet<>();
20     Stream<String> stream2 = set.stream();
21 ?
22     Map<String,String> map = new HashMap<>();
23     //获取键,存储到一个Set集合中
24     Set<String> keySet = map.keySet();
25     Stream<String> stream3 = keySet.stream();
26 ?
27     //获取值,存储到一个Collection集合中
28     Collection<String> values = map.values();
29     Stream<String> stream4 = values.stream();
30 ?
31     //获取键值对(键与值的映射关系 entrySet)
32     Set<Map.Entry<String, String>> entries = map.entrySet();
33     Stream<Map.Entry<String, String>> stream5 = entries.stream();
34 ?
35     //把数组转换为Stream流
36     Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
37     //可变参数可以传递数组
38     Integer[] arr = {1,2,3,4,5};
39     Stream<Integer> stream7 = Stream.of(arr);
40     String[] arr2 = {"a","bb","ccc"};
41     Stream<String> stream8 = Stream.of(arr2);
42 }
43 }
View Code

3.stream流只能使用一次?为什么?

首先我们要知道,stream流属于管道流,只能被消费一次,当第一个stream流调用完毕方法,数据就会流向下一个stream流,所以第一个stream流就没数据了,关闭了。

4.映射,将一个stream流的数据转换为另一种stream流?

如果我们需要将流中的元素映射到一个流中,我们可以使用map方法

代码:

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 /*
 6     Stream流中的常用方法_map:用于类型转换
 7     如果需要将流中的元素映射到另一个流中,可以使用map方法.
 8     <R> Stream<R> map(Function<? super T, ? extends R> mapper);
 9     该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。
10     Function中的抽象方法:
11         R apply(T t);
12  */
13 public class Stream_map {
14     public static void main(String[] args) {
15         //获取一个String类型的Stream流
16         Stream<String> stream = Stream.of("1", "2", "3", "4");
17         //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
18         Stream<Integer> stream2 = stream.map((String s)->{
19             return Integer.parseInt(s);
20         });
21         //遍历Stream2流
22         stream2.forEach(i-> System.out.println(i));
23     }
24 }
View Code

5.终结方法,将一个stream流的数据count?

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 ?
 6 public class StreamCount {
 7     public static void main(String[] args) {
 8         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
 9         Stream<String> result = original.filter(s -> s.startsWith("张"));
10         System.out.println(result.count()); // 2
11     }
12 ?
13 }
View Code

6.取用前几个:limit

参数是一个long型,如果集合当前长度大于参数则进行截取;否则不进行操作。基本使用:

 1 package cn.fan;
 2 import java.util.stream.Stream;
 3 ?
 4 public class StreamLimit {
 5     public static void main(String[] args) {
 6         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
 7         Stream<String> result = original.limit(2);
 8         System.out.println(result.count()); // 2
 9     }
10 }
View Code

7.跳过前几个:skip?

如果希望跳过前几个元素,可以使用 skip 方法获取一个截取之后的新流:

Stream skip(long n);

如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 public class StreamSkip {
 6     public static void main(String[] args) {
 7         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
 8         Stream<String> result = original.skip(2);
 9         System.out.println(result.count()); // 1
10     }
11 ?
12 }
View Code

8.组合:concat?

如果有两个流,希望合并成为一个流,那么可以使用 Stream 接口的静态方法 concat :

static Stream concat(Stream a, Stream b)

备注:这是一个静态方法,与 java.lang.String 当中的 concat 方法是不同的。

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 public class StreamConcat {
 6     public static void main(String[] args) {
 7         Stream<String> streamA = Stream.of("张无忌");
 8         Stream<String> streamB = Stream.of("张翠山");
 9         Stream<String> result = Stream.concat(streamA, streamB);
10     }
11 }
View Code

 

 


原文链接:https://www.cnblogs.com/fan123yh/p/11115157.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:多线程与高并发(二)线程安全

下一篇:匿名内部类和Lambda表达式是一样的吗?