java8新特性-Stream流
菜鸟Stream
什么是Stream
-
是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。
“集合讲的是数据,流讲的是计算!” -
Stream流是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。
-
Stream的优点:声明性,可复合,可并行。这三个特性使得stream操作更简洁,更灵活,更高效。
-
Stream的操作有两个特点:可以多个操作链接起来运行,内部迭代。
-
Stream可分为并行流与串行流,Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。串行流就不必再细说了,并行流主要是为了为了适应目前多核机器的时代,提高系统CPU、内存的利用率,并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。java1.8并行流使用的是fork/join框架,fork/join
注意 :
-
1、Stream不会自己存储数据。
-
2、Stream不会改变原对象,他们会返回一个新的Stream。
-
3、Stream操作是延迟的,他们会等到需要的结果时才执行。
-
4、使用并行流并不一定会提高效率,因为jvm对数据进行切片和切换线程也是需要时间的。
Stream 的操作三个步骤
- 创建 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");
中间操作
- 中间操作,即对数据源进行一系列的操作处理。
- 多个中间操作可以连接起来性格一条流水线,除非流水线上触发器终止操作,否则中间操作不会执行任何的处理,而是在终止操作时一次性全部处理,成为‘‘惰性求值’’。
筛选和切片
方法 | 描述 |
---|---|
filter(Predicate p) | 接收 Lambda , 从流中排除某些元素。 |
distinct() | 筛选,通过流所生成元素的 hashCode() 和 equals() 去 除重复元素 |
limit(long maxSize) | 截断流,使其元素不超过给定数量。 |
skip(long n) | 跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素 不足 n 个,则返回一个空流。与 limit(n) 互补 |
/**
* 打印年龄大于18的前4位用户信息(不重复)
* 并跳过第1个用户
*/
@Test
public void test1(){
list.stream()
.filter((x)->x.getAge()>18)
.distinct()
.limit(4)
.skip(1).forEach(System.out::println);
}
映射
方法 | 描述 |
---|---|
map(Function f) | 接收一个函数作为参数,该函数会被应用到每个元 素上,并将其映射成一个新的元素。 |
mapToDouble(ToDoubleFunction f) | 接收一个函数作为参数,该函数会被应用到每个元 素上,产生一个新的 DoubleStream。 |
mapToInt(ToIntFunction f) | 接收一个函数作为参数,该函数会被应用到每个元 素上,产生一个新的 IntStream。 |
mapToLong(ToLongFunction f) | 接收一个函数作为参数,该函数会被应用到每个元 素上,产生一个新的 LongStream。 |
flatMap(Function f) | 接收一个函数作为参数,将流中的每个值都换成另 一个流,然后把所有流连接成一个流 |
flatMap是解决流中嵌套流比如{{a,a,a},{b,b,b}},它会把这些流转换成一个流{a,a,a,b,b,b}方便处理
@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();
}
排序
方法 | 描述 |
---|---|
sorted() | 产生一个新流,其中按自然顺序排序 |
sorted(Comparator comp) | 产生一个新流,其中按比较器顺序排序 |
@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);
}
查找与匹配
方法 | 描述 |
---|---|
allMatch(Predicate p) | 检查是否匹配所有元素 |
anyMatch(Predicate p) | 检查是否至少匹配一个元素 |
noneMatch(Predicate p) | 检查是否没有匹配所有元素 |
findFirst() | 返回第一个元素 |
findAny() | 返回当前流中的任意元素 |
@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());
}
归约
方法 | 描述 |
---|---|
reduce(T iden, BinaryOperator b) | 可以将流中元素反复结合起来,得到一个值。 返回 T |
reduce(BinaryOperator b) | 可以将流中元素反复结合起来,得到一个值。 返回 Optional |
Stream 的终止操作
方法 | 描述 |
---|---|
count() | 返回流中元素总数 |
max(Comparator c) | 返回流中最大值 |
min(Comparator c) | 返回流中最小值 |
forEach(Consumer c) | 内部迭代(使用 Collection 接口需要用户去做迭 代,称为外部迭代。相反,Stream API 使用内部 迭代——它帮你把迭代做了) |
collect(Collector c) | 将流转换为其他形式。接收一个 Collector接口的 实现,用于给Stream中元素做汇总的方法 |
@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);
}