摘要
- Stream 是对集合对象功能的增强,它专注于对集合对象进行各种非常便利、高效的聚合操作,或者大批量数据操作。通常我们需要多行代码才能完成的操作,借助于Stream流式处理可以很简单的实现。
- Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的。
创建Steam流
-
调用
Collection.stream()
函数创建一个Stream对象 - Stream 接口的静态方法 of 可以获取数组对应的流
1
2
3
4
5
|
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
String[] arr = { "张三" , "李四" , "王五" };
Stream<String> stream2 = Stream.of(arr);
|
常用方法
-
void forEach(Consumer<? super T> action)
:该方法接收一个Consumer接口函数,会将每一个流元素交给该函数进行处理。此方法为终结方法,遍历后不能再调用Stream流的其他方法。
Consumer<T>函数式接口是一个消费型接口。 Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据。
1
2
3
4
5
6
7
8
9
10
11
12
|
import java.util.stream.Stream;
public class Start {
public static void main(String[] args) {
String[] arr = { "张三" , "李四" , "王五" };
Stream<String> stream2 = Stream.of(arr);
stream2.forEach((name)->{
System.out.println(name);
});
}
}
|
-
Stream<T> filter(Predicate<? super T> predicate)
:将一个流转换成另一个子集流,此方法为终结方法。
Predicate<T>函数式接口,抽象方法boolean test(T t)用来对指定数据进行判断是否满足条件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
import java.util.stream.Stream;
public class Start {
public static void main(String[] args) {
//获取Stream流
String[] arr = { "张三" , "李四" , "王五" };
Stream<String> stream2 = Stream.of(arr);
//filter方法
Stream<String> fil = stream2.filter((name) -> {
return name.startsWith( "张" );
});
fil.forEach(name->System.out.println(name));
}
}
|
-
Stream<R> map(Function<? super T, ? extends R> mapper)
:将流中的元素映射到另一个流中。
Function<T>函数式接口,可以将当前流中的T类型数据转换为另一种R类型的流。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
import java.util.stream.Stream;
public class Start {
public static void main(String[] args) {
//获取Stream流
String[] arr = { "1" , "2" , "3" };
Stream<String> stream2 = Stream.of(arr);
//map方法
Stream<Integer> map = stream2.map((string) -> {
return Integer.parseInt(string);
});
map.forEach(integer->System.out.println(integer));
}
}
|
-
long count()
:统计流中元素的个数,此方法为终结方法。 -
Stream<T> limit(long n)
:用于截取流中的元素,只取用前n个元素,此方法是延迟方法,可以继续调用Stream流中的其他方法。
stream1.limit(2).forEach(name -> System.out.println(name));
-
Stream<T> skip(long n)
:用于跳过流中的元素,跳过n个元素,获取剩下的元素组成新流,此方法是延迟方法。
stream1.skip(1).forEach(name -> System.out.println(name));
-
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
:Stream的静态方法,将两个流合并为一个流。
Stream.concat(stream1, stream2).forEach(string -> System.out.println(string));
以上就是详解JAVA Stream流的详细内容,更多关于JAVA Stream流的资料请关注服务器之家其它相关文章!
原文链接:https://www.cnblogs.com/geqianLee/p/13399680.html