Stream流

Stream 流

1.1 案例1 Stream 流重新对数组进行过滤并且遍历打印

package stream;

import java.util.ArrayList;

public class Filter {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> name = new  ArrayList<>();
		name.add("张三丰");
		name.add("张无忌");
		name.add("科比");//filter函数的参数是Predicate是一个函数式接口因此可以用lambda来写
		name.stream().filter((str)->{return str.startsWith("张");})
					 .filter((str)->{return str.length()==3;})//这里其实就是链式的编程思想
					 .forEach((str)->{System.out.println(str);})；//参数是Consumer函数式接口
		}

}

1.2 流式思想概述

首先对函数模型进行处理，最后才对集合进行处理，这得益于lambda的延迟处理特性。Stream是一种来自数据源的元素队列

备注：stream流其实是一个集合元素的函数模型，他并不是集合也不是数据结构，其本身并不存在任何元素或者其地址。

数据流的来源可以是集合也可以是数组或者其他。

1.3 获取流

1. JDK8之后所有Collection集合都可以通过stream默认方法来获得流，但是所有的Map集合是没有的

2. stream接口的静态方法 of可以获取数组对应的流

   集合转换为stream

List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
//Set 转换为流
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
//获取键，存储在一个set集合
Map<String> map = new HashMap<>();
Set<String> keySet = map.keySet();
Stream<String> stream3 = keySet.stream();
//获取值
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();
//获取键值对
Set<Map.Entry<String,String>> entries = map.entrySet();
Stream<String> stream5 = entries.stream();

利用Stream的静态方法of

Stream<Integer> stream = Stream.of(1,2,3,4);
int[] arr ={1,23,4};
Stream<Integer> stream1 = Stream.of(arr);

1.4 常用方法

延迟方法：返回值仍然是stream接口。因此支持链式调用(除终结方法外其余方法都是延迟方法)

终结方法：返回值不再是stream接口自身类的方法，本小结终结方法包括count和forEach 方法

1. 逐一处理： forEach

void forEach<Consumer<? super T> actions;//参数是函数式接口可以接收lambda

用来遍历流中的数据

public static void main(String[] args){
    Stream<String> stream = Stream.of("张三","里斯");
    Stream.forEach((String name)->{System.out.println(name);});
}//为什么这里的lambda是有参数的因为/Consumer的accept 方法是有参数的

2. 过滤：filter

Stream<T> filter<Predicate<? super T >predicate>; 

public static void main(String[] args){
    Stream<String> stream = Stream.of("张三","里斯");
    stream.filter((name)->{return name.startWith("张");});

3. 映射方法：map

   如果要将流中的元素映射到另一个流中，可以使用map方法。方法签名：

   将一种数据转换成另外一种类型

   <R> Stream<R> map(Function<? super T,? extends R> mapper);

   public static void main(String[] args){
       Stream<String> stream = Stream.of("1","2");
       Stream1 = stream.map((String s)->{return Integer.parseInt(s);});
       stream1.forEach((Integer i)->{System.out.print(i);});
   
   
   
   }
   

   4. count方法

      用来统计stream流中的元素个数返回值是long类型是一个终结方法

      public static void main(String[] args){
          Stream<String> stream = Stream.of("张三","里斯");
          long nums = stream.count();//无参数函数

   5. 取用前几个方法limit

      可以对流进行截取，只取用前几个。方法签名：

      Stream<T> limit(long maxsize);//返回值是流是延迟方法，如果截取的值比原来的还要大的话就不进行操作

      public static void main(String[] args){
          Stream<String> stream = Stream.of("张三","里斯");
          Stream<String> stream1 = Stream.limit(1);

4. skip

   如果希望跳过前几个元素，那么可以使用这个方法来获取结截取之后新的流

   Stream<T> skip(long n);

   public static void main(String[] args){
       Stream<String> stream = Stream.of("张三","里斯");
       Stream<String> stream1 = Stream.skip(1);
   }

5. 组合方法 concat

   static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

   public static void main(String[] args){
       Stream<String> stream = Stream.of("张三","里斯");
       Stream<String> stream1 = Stream.of("王五");
       Stream<String> stream2 = Stream.concat(stream,stream1);
   }

1.5 Stream 流的特点

是管道流只可以使用一次

Stream<String> stream = Stream.of("sfdsadf","sdfsdf");
stream.forEach();
//继续下面的代码会报错
stream.filter();

1.6 练习集合元素的处理

Person类代码

package stream;

public class Person {
	private String name;

	public Person(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + "]";
	}

	public void setName(String name) {
		this.name = name;
	}
}

主程序代码

package stream;

import java.util.ArrayList;
import java.util.stream.Stream;

public class Allcontent {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> name = new ArrayList<>();
		name.add("张三丰");
		name.add("张无忌");
		name.add("张三李四");
		name.add("玄冥二老");
		name.add("周芷若");
		name.add("雷锋");
		Stream<String> stream1 = name.stream().filter((String s)->{return s.length()==3;})
											  .limit(3);
		Stream<String> stream2 = name.stream().filter((String s)->{return s.startsWith("张");})
											 .skip(2);
		Stream<String> stream3 = Stream.concat(stream1, stream2);
	
		Stream<Person> stream4 = stream3.map((String s)->{return new Person(s);});
		stream4.forEach((person)->{System.out.println(person);});
								

	}

}