什么是Stream?
Stream流是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。
Stream的优点:声明性,可复合,可并行。这三个特性使得stream操作更简洁,更灵活,更高效。
Stream(流)是一个来自数据源的元素队列并支持聚合操作。元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
数据源:流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
聚合操作:类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等。
和以前的Collection操作不同, Stream操作还有两个基础的特征:
Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。> 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。 内部迭代:
以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。> Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。
Stream可分为并行流与串行流,Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。串行流就不必再细说了,并行流主要是为了为了适应目前多核机器的时代,提高系统CPU、内存的利用率,并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。
注意 :
- 1、Stream不会自己存储数据。
- 2、Stream不会改变原对象,他们会返回一个新的Stream。
- 3、Stream操作是延迟的,他们会等到需要的结果时才执行。
- 4、使用并行流并不一定会提高效率,因为jvm对数据进行切片和切换线程也是需要时间的。
当使用一个流的时候,通常包括三个基本步骤:获取一个数据源(source)→ 数据转换→执行操作获取想要的结果,每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以像链条一样排列,变成一个管道。
当需要对多个元素进行操作(特别是多步操作)的时候,考虑到性能及便利性,应该首先拼好一个“模型”步骤
方案,然后再按照方案去执行它。
这张图中展示了过滤、映射、跳过、计数等多步操作,这是一种集合元素的处理方案,而方案就是一种“函数模
型”。图中的每一个方框都是一个“流”,调用指定的方法,可以从一个流模型转换为另一个流模型。而最右侧的数字
3是最终结果。
这里的 filter 、 map 、 skip 都是在对函数模型进行操作,集合元素并没有真正被处理。只有当终结方法 count
执行的时候,整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性
备注:“Stream流”其实是一个集合元素的函数模型,它并不是集合,也不是数据结构,其本身并不存储任何
元素(或其地址值)。
如何创建Stream?
创建Stream,就是将一个数据源 (如:集合、数组)转化为一个流。
1、通过Collection系列提供的stream()(串行) 或parallelStream()(并行)获取数据流。
2、通过Arrays中的静态方法stream() 获取数据流。
3、通过Stream类中的静态方法of()获取数据流。
1、通过Collection系列提供的stream()(串行) 或parallelStream()(并行)获取
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();//串行流
Stream<String> stream2 = list.parallelStream();//并行流
2、通过Arrays中的静态方法stream() 获取数据流
User[] u = new User[2];
Stream<User> stream3 = Arrays.stream(u);
3、通过Stream;类中的静态方法of()
Stream<String> stream4 = Stream.of("11","2");
根据Collection获取流:
首先, java.util.Collection 接口中加入了default方法 stream 用来获取流,所以其所有实现类均可获取流.
package Demo02;
import java.util.*;
import java.util.stream.Stream;
public class Demo04Collection {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
Vector<String> vector = new Vector<>();
Stream<String> stream3 = vector.stream();
}
}
根据Map获取流:
java.util.Map 接口不是 Collection 的子接口,且其K-V数据结构不符合流元素的单一特征,所以获取对应的流需要分key、value或entry等情况:
package Demo02;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
public class Demo05Map {
public static void main(String[] args){
Map<String,String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String,String>> entrys = map.entrySet().stream();
}
}
根据数组获取流
如果使用的不是集合或映射而是数组,由于数组对象不可能添加默认方法,所以 Stream 接口中提供了静态方法of ,使用很简单:
package Demo02;
import java.util.stream.Stream;
public class Demo06GetStream {
public static void main(String[] args){
String[] array = {"私","忆","一","秒","钟"};
Stream<String> stream = Stream.of(array);
}
常用方法
流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:
延迟方法:返回值类型仍然是 Stream 接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方法均为延迟方法。)
终结方法:返回值类型不再是 Stream 接口自身类型的方法,因此不再支持类似 StringBuilder 那样的链式调用。
中间操作
中间操作,即对数据源进行一系列的操作处理。
多个中间操作可以连接起来性格一条流水线,除非流水线上触发器终止操作,否则中间操作不会执行任何的处理,而是在终止操作时一次性全部处理,成为惰性求值。
筛选和切片
1、filter(predicate)-接收lambda,从流中排除某些元素。
2、limit(n)-截断流,使其元素不超过给定数量。
3、skip(n)-跳过元素,返回一个扔掉了前n个元素的流。若流中元素不足n个,则返回一个空流,与limit(n)互补。
4、distinct-筛选,通过流所生成元素的hashcode()和equals()去重复元素。
/**
* 打印年龄大于18的前4位用户信息(不重复)
* 并跳过第1个用户
*/
@Test
public void test1(){
list.stream()
.filter((x)->x.getAge()>18)
.distinct()
.limit(4)
.skip(1).forEach(System.out::println);
}
逐一处理:forEach
虽然方法名字叫 forEach ,但是与for循环中的“for-each”昵称不同。
void forEach(Consumer<? super T> action); 该方法接收一个 Consumer 接口函数,会将每一个流元素交给该函数进行处理。
import java.util.stream.Stream;
public class Demo4ForEach {
public static void main(String[] args) {
Stream.of("张三", "李四", "王五", "赵六", "田七")
.forEach(name -> System.out.println(name));
}
}
过滤:filter
可以通过 filter 方法将一个流转换成另一个子集流。方法签名:
Stream filter(Predicate<? super> T> predicate);
该接口接收一个 Predicate 函数式接口参数(可以是一个Lambda或方法引用)作为筛选条件。
基本用法:
import java.util.stream.Stream;
public class Demo5Filter {
public static void main(String[] args) {
Stream.of("张三丰", "张翠山", "王五", "张无忌", "赵六")
.filter(name -> name.startsWith("张"))
.forEach(name -> System.out.println(name));
}
}
映射
1、map,接收Lambda,将元素转换成其他形式或提取信息。接收一个函数作为参数,该函数会被应用到每一个元素上,并将其映射成一个新的元素。
2、mapToDouble/mapToInt/mapToLong,接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的DoubleStream/IntStream/LongStream。
3 、flatMap,接收一个函数作为参数,将流中的每个值都换成一个流,然后把流连接成一个流。
@Test
public void test2(){
///map
list.stream().map(User::getName)
.forEach(System.out::println);
//flatMap
List<List<User>> list1 = new ArrayList<>();
list1.add(list);
list1.stream().flatMap(Stream::getNames)
.forEach(System.out::println);
}
public static Stream<String> getNames(List<User> list){
List<String> list1 = new ArrayList<String>();
for (User user : list) {
list1.add(user.getName());
}
return list1.stream();
}
映射:map
如果需要将流中的元素映射到另一个流中,可以使用 map 方法。方法签名: Stream map(Function<?> super T, ? extends R> mapper); 该接口需要一个 Function
函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。
基本用法:
Stream流中的 map 方法基本使用的代码如:
import java.util.stream.Stream;
public class Demo5Map {
public static void main(String[] args) {
Stream.of("1", "2", "3", "4")
.map(s -> Integer.parseInt(s))
.forEach(s -> System.out.println(s));
}
}
映射:flatMap
实现流的合并。
排序
1、sorted(),产生一个新流,其中按自然顺序排序。
2、sorted(Comparator),产生一个新流,其中按比较器顺序排序。
@Test
public void test3(){
List<String> list =Arrays.asList("aa","bb","cc","dd");
list.stream().sorted()
.forEach(System.out::println);
//
list.stream().sorted((x,y) -> {
if(x.equals(y)){
return 1;
}else{
return -1;
}
} ).forEach(System.out::println);
}
统计个数:count
正如旧集合 Collection 当中的 size 方法一样,流提供 count 方法来数一数其中的元素个数: long count();
该方法返回一个long值代表元素个数(不再像旧集合那样是int值)。基本使用:
import java.util.ArrayList;
import java.util.List;
public class Demo7Count {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
long count = list.stream().count();
System.out.println(count);
}
}
截取前几个:limit
limit 方法可以对流进行截取,只取用前n个。
方法签名: Stream limit(long maxSize);
参数是一个long型,如果集合当前长度大于参数则进行截取;否则不进行操作。
基本用法:
import java.util.stream.Stream;
public class Demo8Limit {
public static void main(String[] args) {
Stream.of("美羊羊","喜羊羊","懒羊羊","灰太狼")
.limit(3)
.forEach(s -> System.out.println(s));
}
}
跳过前几个:skip
如果希望跳过前几个元素,可以使用 skip 方法获取一个截取之后的新流: Stream skip(long n);
如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。
基本用法:
import java.util.stream.Stream;
public class Demo9Skip {
public static void main(String[] args) {
Stream.of("美羊羊","喜羊羊","懒羊羊","灰太狼", "红太狼")
.skip(3)
.forEach(s -> System.out.println(s));
}
}
组合:concat
如果有两个流,希望合并成为一个流,那么可以使用 Stream 接口的静态方法 concat :
static Stream concat(Stream<? extends T> a, Stream<? extends T> b)
备注:这是一个静态方法,与 java.lang.String 当中的 concat 方法是不同的。
import java.util.stream.Stream;
public class Demo10Concat {
public static void main(String[] args) {
Stream<String> streamA = Stream.of("张三丰", "张翠山", "王五", "张无忌", "赵六");
Stream<String> streamB = Stream.of("美羊羊","喜羊羊","懒羊羊","灰太狼", "红太狼");
Stream.concat(streamA, streamB).forEach(s -> System.out.println(s));
}
}
终止操作
终止操作是执行中间操作链,并产生结果(一个新流),数据源本身并不受影响,其结果可以是任何不是流的值。
查找与匹配
1、allMatch,检查是否匹配所有元素。
2、anyMatch,检查是否至少匹配一个元素。
3、noneMatch,检查是否没有匹配所有元素。
4、findFirst,返回第一个元素。
5、findAny,返回当前流中的任意元素。
6、count,返回流中元素的总数。
7、max,返回流中最大值。
8、min,返回流中最小值。
9、forEach(Consumer c) 内部迭代。
@Test
public void test4(){
boolean b = list.stream().
noneMatch((e) ->
e.getName().equals("zhao"));
System.out.println(b);
Optional<User> op = list.parallelStream()
.filter((x) -> x.getAge() == 18)
.findAny();
System.out.println(op.get());
}
Collectors代码示例:
@Test
public void test5(){
//转List
List<String> list1 =list.stream()
.map(User::getName)
.collect(Collectors.toList()) ;
list1.forEach(System.out::println);
//转HashSet
HashSet<String> set = list.stream().
map(User::getName)
.collect(Collectors.toCollection(HashSet::new));
set.forEach(System.out::println);
//总数
Long count = list.stream()
.collect(Collectors.counting());
System.out.println(count);
//平均年龄
double avAge = list.stream()
.collect(Collectors.averagingInt(User::getAge));
System.out.println(avAge);
//总年龄
int toAge = list.stream()
.collect(Collectors.summingInt(User::getAge));
System.out.println(toAge);
//最大值
Optional<User> u = list.stream()
.collect(Collectors.maxBy((e1,e2)
-> Integer.compare(e1.getAge(),e2.getAge() )));
System.out.println(u);
//平均年龄
IntSummaryStatistics collect = list.stream()
.collect(Collectors.summarizingInt(User::getAge));
System.out.println(collect.getAverage());
//分组
Map<Integer, List<User>> l= list.stream()
.collect(Collectors.groupingBy(User::getAge));
System.out.println(l);
//多级分组
Map<Integer,Map<String,List<User>> > ls= list.stream()
.collect(Collectors.groupingBy(
User::getAge,Collectors.groupingBy(User::getSex)));
System.out.println(ls);
//分区
Map<Boolean,List<User>> map= list.stream()
.collect(Collectors.partitioningBy((x)
-> x.getAge()>18));
System.out.println(map);
//连接字符串
String str = list.stream().map(User::getName)
.collect(Collectors.joining(",","-","-"));
System.out.println(str);
}