1. Stream流对象介绍
java.util.stream.Stream<T>;是JDK8新加入的最常用的流接口
常用的获取流的方式
(1)所有的Collection集合都可以通过stream默认方法获取流;
default Stream<E> stream();
(2)Stream接口的静态方法of可以获取数组对应的流
static <T> Stream<T> of(T... value);
参数是一个可变参数,那么我们就可以传递一个数组。
Stream流的属于管道流,只能被使用一次,第一个Stream流调用完毕以后数据就会流向下一个Stream上,此时第一个Stream流已经关闭,不能在使用第一个Stream流调用方法
Stream流的常用方法:延迟方法返回是一个流,仍然可以调用流的方法,
(1)filter();延迟方法,用于过滤流中的元素,返回的还是一个流。
源码:Stream<T> filter(Predicate<? super T> predicate);
(2)forEach();延迟方法,用于循环输出流中的元素
源码:void forEach(Consumer<? super T> action);
(3)count();用于统计Stream流中元素的个数,返回值是一个long类型的数据
(4)limit();延迟方法,对流中的元素进行截取,返回的还是一个流,所以可以继续调用其他Stream流的方法
源码:Stream<T> limit(long maxSize);
(5)skip();延迟方法,希望跳过前n个元素,获取n元素之后元素形成一个新流。
源码:Stream<T> skip(long n);
(6)concat();延迟方法,把两个流组合在一起,形成一个新的流
源码:
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
@SuppressWarnings("unchecked")
Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
(Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
return stream.onClose(Streams.composedClose(a, b));
}
2.案例
public static void main(String[] args) {
Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
//map方法案例
/*stream.map(str-> Integer.valueOf(str))//map方法中传入的是Function函数式接口,实现数据类型转换,该接口中的抽象方法是apply方法,用于数据类型转换
.forEach(s-> System.out.println(s));结果:1 2 3 4 5 */
//count方法案例
/*long count = stream.count();
System.out.println(count);//结果:5*/
//limit方法案例
/*Stream<String> stream2 = stream.limit(3);
stream2.forEach(s-> System.out.println(s));//结果:1 2 3*/
//skip方法案例
/* Stream<String> stream3 = stream.skip(3);
stream3.forEach(s-> System.out.println(s));//结果:4 5*/
//concat方法案例
/*Stream<String> stream4 = Stream.of("a", "b", "v", "b");
Stream<String> stream5 = Stream.concat(stream, stream4);
stream5.forEach(s-> System.out.println(s));//1 2 3 4 5 a b v b*/
}
3. 对list集合的优化
(1)原代码:
//获取list集合中,元素包含a,且长度为3的元素,并打印
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("ABB");
list.add("Bcc");
list.add("CsA");
List<String> listA = new ArrayList<>();
for (String s : list) {
if(s.contains("A")){
listA.add(s);
}
}
List<String> listB = new ArrayList<>();
for (String s : listA) {
if(s.length()==3){
listB.add(s);
}
}
for (String s : listB) {
System.out.println(s);
}
}
(2)优化代码:
//使用stream流对集合遍历进行优化
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("ABB");
list.add("Bcc");
list.add("CsA");
list.stream().filter(s -> s.contains("A"))//该方法中传入的是一个Predicate函数式接口,实现过滤,接口中的抽象方法为test方法,用于判断
.filter(s->s.length()==3)
.forEach(s->System.out.println(s));//该方法中传入的是一个Consumer函数式接口,实现循环,该接口中的抽象方法是accept方法,用于消费
}