Stream流
对比:
package com.py.Stream;
import java.util.ArrayList;
import java.util.List;
public class DemoStreamFilter {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("霍元甲");
list.add("张无忌");
list.add("杨过");
list.add("张文");
// 过滤获得一张开头的名字
ArrayList<String> nlist = new ArrayList<>();
for (String i :
list) {
if (i.startsWith("张")){
nlist.add(i);
}
}
// 循环得到字符长度为3的名字
for (String i :
nlist) {
if (i.length()==3){
System.out.println(i);
}
}
}
}
package com.py.Stream;
import java.util.ArrayList;
public class DemoStreamFilter01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("霍元甲");
list.add("张无忌");
list.add("杨过");
list.add("张文");
// 过滤获得一张开头的名字
// 循环得到字符长度为3的名字
// 遍历
list.stream()
.filter(name->name.startsWith("张"))
.filter(name->name.length()==3)
.forEach(naem-> System.out.println(naem));
}
}
获取Stream流的方法
-
所有的Collection集合(单列集合)都可以通过Strem方式获得流
- java.util.Interface Collection
default Stream
stream() 返回以此集合作为源的顺序 Stream 。 - java.util.Interface Collection
-
Stream接口的静态方法of可以获得数组对应的流
- java.util.stream.Interface Stream
- java.util.stream.Interface Stream
集合间的关系
实例
package com.py.Stream;
import java.util.*;
import java.util.stream.Stream;
public class DemoGetStream {
public static void main(String[] args) {
//把ArraryList转换为流
ArrayList<String> list = new ArrayList<>();
Stream<String> stream01 = list.stream();
//将set转化为流
Set<String> set = new HashSet<>();
Stream<String> stream02 = set.stream();
//Map转化为stream流
Map<String,String> map = new HashMap<>();
//将键转化为流
Stream<String> stream03 = map.keySet().stream();
//将值转化为流
Stream<String> stream04 = map.values().stream();
//获取键值对
Stream<Map.Entry<String, String>> stream05 = map.entrySet().stream();
//将数组转化为流
Stream<Integer> stream06 = Stream.of(1, 2, 3, 4, 5, 6);
//int类型
Integer[] integer = {1,2,3,4,5,6};
Stream<Integer> stream07 = Stream.of(integer);
//String类型
String [] str = {"ni","aef","zsdf","dsfg"};
Stream<String> stream08 = Stream.of(str);
}
}
常用方法
常用的方法分为两类:
- 延迟方法:返回值仍然是
Stream
流接口的方法,支持链式调用 - 终结方法: 返回值类型不再是
stream
流接口的方法,因此不再支持类似的链式调用
forEach
返回值 | 方法 | 描述 |
---|---|---|
void |
forEach(Consumer<? super T> action) |
对此流的每个元素执行操作。【接口方法】 |
Consumer 接口中包含抽象方法void accept(T t),消费一个指定泛型的数据。
T:流中的元素类型
Filter
返回值 | 方法 | 描述 |
---|---|---|
Stream<T> |
filter(Predicate<? super T> predicate) |
返回由与此给定谓词匹配的此流的元素组成的流。 |
Predicate:函数式接口,可以使用lambda表达式对数据进行过滤。
抽象方法 test(T t)
Map
返回值 | 方法 | 描述 |
---|---|---|
<R> Stream<R> |
map(Function<? super T,? extends R> mapper) |
返回由给定函数应用于此流的元素的结果组成的流。【映射为其他类型】 |
Function:函数式接口,可以使用lambda表达式进行映射
抽象方法:R apply (T);
Count
返回值 | 方法 | 描述 |
---|---|---|
long |
count() |
返回此流中的元素数。 |
此方法是一个终结方法,统计流中元素个数,调用后不能继续使用。
Limit
返回值 | 方法 | 描述 |
---|---|---|
Stream<T> |
limit(long maxSize) |
返回由此流的元素组成的流,截短长度不能超过 maxSize 。 |
截取前maxSize位的元素,组成一个新的流。
Skip
返回值 | 方法 | 描述 |
---|---|---|
Stream<T> |
skip(long n) |
在丢弃流的第一个 n 元素后,返回由该流的 n 元素组成的流。 |
丢弃前n个元素后,追成一个新的流。
Concat
返回值 | 方法 | 描述 |
---|---|---|
static <T> Stream<T> |
concat(Stream<? extends T> a, Stream<? extends T> b) |
创建一个懒惰连接的流,其元素是第一个流的所有元素,后跟第二个流的所有元素。 |
练习
package com.py.Stream;
import java.util.stream.Stream;
public class DemoStreamMethor {
public static void main(String[] args) {
Stream<String> stream = Stream.of("张三", "李四", "王五", "刘六", "田七");
// filter(stream);
// count(stream);
// limit(stream);
// skip(stream.skip(3));
}
private static void skip(Stream<String> skip) {
skip
.forEach(name -> {
System.out.println(name);
});
}
private static void limit(Stream<String> stream) {
skip(stream.limit(3));
}
private static void count(Stream<String> stream) {
System.out.println(stream.count());
}
private static void filter(Stream<String> stream) {
stream.filter((String name)->{ return name.startsWith("张");})
.forEach((name->{System.out.println(name);}));
}
}
实例
package com.py.Stream;
import java.util.ArrayList;
import java.util.stream.Stream;
public class DemoTest {
public static void main(String[] args) {
ArrayList<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("迪丽热巴");
one.add("苏星河");
one.add("石破天");
one.add("老子");
Stream<String> oneStream = one.stream().filter(name -> {
return name.length() == 3;
}).limit(3);
ArrayList<String > two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖女");
two.add("张三丰");
two.add("赵四");
two.add("汪远");
two.add("铃木爱理");
Stream<String> twoStream = two.stream().filter(name -> {
return name.length() == 4;
}).skip(1);
Stream.concat(oneStream,twoStream).map(name->{return new Person(name);}).forEach(p->{
System.out.println(p);
});
}
}