Stream流学习记录

Stream流的使用生成流
生成流：通过数据源(集合,数组等)生成流      list.stream()
中间操作：一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用      filter(）
终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作      forEach(）

Stream流的常见生成方式：
1.Collection体系的集合可以使用默认方法stream()生成流
default Stream<E> stream(）
2.Map体系的集合间接的生成流
3.数组可以通过Stream接口的静态方法of(T... values)生成流
 

package stream;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.stream.Stream;

public class Streamdemo1 {
		public static void main(String[] args) {
		//Collection体系的集合可以使用默认方法stream ()生成流
        List<String> list=new ArrayList<String>();
        Stream<String> sl=list.stream();
        Set<String> set=new HashSet<String>();
        Stream<String> ss=set.stream();
		//Map体系的集合间接的生成流
        Map<String,Integer> map=new HashMap<String,Integer>();
        Stream<String> sk= map.keySet().stream();
        Stream<Integer> sv=map.values().stream();
        Stream<Map.Entry<String, Integer>> se=map.entrySet().stream();
		//数组可以通过stream接口的静态方法of (T... values)生成流
        String[] s= {"hello","java","world"};
        Stream<String> so=Stream.of(s);
        Stream<String> soo=Stream.of("hello","java","world");
        Stream<Integer> si=Stream.of(12,454,457);
	}

}

Stream流的常见中间操作方法
1.Stream<T> filter(Predicate predicate):用于对流中的数据进行过滤Predicate接口中的方法
boolean test(T t):对给定的参数进行判断，返回一个布尔值

package stream;

import java.util.List;
import java.util.ArrayList;

public class Streamdemo2 {

	public static void main(String[] args) {
	 List<String> list=new ArrayList<String>();
	 list.add("林青霞");
	 list.add("张曼玉");
	 list.add("王祖贤");
	 list.add("柳岩");
	 list.add("张敏");
	 list.add("张无忌");
	//需求1:把list集合中以张开头的元素在控制台输出
	list.stream().filter(s->s.startsWith("张")).forEach(System.out::println);
	//需求2:把list集合中长度为3的元素在控制台输出
	list.stream().filter(s->s.length()==3).forEach(System.out::println);
	//需求3:把List集合中以张开头的，长度为3的元素在控制台输出
    list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);

	}

}

2.Stream<T> limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据
3.Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
 

package stream;

import java.util.ArrayList;
import java.util.List;

/*
 *   Stream<T> limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据
     Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
 */
public class Streamdemo3 {
    public static void main(String[] args) {
   	 List<String> list=new ArrayList<String>();
   	 list.add("林青霞");
   	 list.add("张曼玉");
   	 list.add("王祖贤");
   	 list.add("柳岩");
   	 list.add("张敏");
   	 list.add("张无忌");
    	//需求1:取前3个数据在控制台输出
   	 list.stream().limit(3).forEach(System.out::println);
      	//需求2:跳过3个元素，把剩下的元素在控制台输出
   	 list.stream().skip(3).forEach(System.out::println);
    	//需求3:跳过2个元素，把剩下的元素中前2个在控制台输出
     list.stream().skip(2).limit(2).forEach(System.out::println);
	}
}

4.static <T> Stream<T> concat(Stream a, Stream b):合并a和b两个流为一个流
5.Stream<T> distinct():返回由该流的不同元素（根据Objectequals(Object)）组成的流

package stream;

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

public class Streamdemo4 {
	public static void main(String[] args) {
	   	 List<String> list=new ArrayList<String>();
	   	 list.add("林青霞");
	   	 list.add("张曼玉");
	   	 list.add("王祖贤");
	   	 list.add("柳岩");
	   	 list.add("张敏");
	   	 list.add("张无忌");
	    //需求1:取前4个数据组成一个流
	   	Stream<String> s1 = list.stream( ).limit(4);
	   	//需求2:跳过2个数据组成一个流
	   	Stream<String> s2 = list.stream( ).skip(2);
	   	//需求3:合并需求1和需求2得到的流，并把结果在控制台输出
	  // 	Stream.concat(s1, s2).forEach(System.out::println);
	   	//需求4:合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
	}

}

6.Stream<T> sorted):返回由此流的元素组成的流，根据自然顺序排序
7.Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

package stream;

import java.util.ArrayList;
import java.util.List;

public class Streamdemo5 {

	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add( "linqingxia" );
		list.add( "zhangmanyu" );
		list.add( "wangzuxian" );
		list.add( "liuyan");
		list.add( "zhangmin" );
		list.add( "zhangwuji");
       //按照字母顺序输出在控制台
		//list.stream().sorted().forEach(System.out::println);
       //按照字符串长度输出在控制台
		list.stream().sorted((s1,s2)->{
		int num=s1.length()-s2.length();
		int num1=num==0?s1.compareTo(s2):num;
		return num1;
		}).forEach(System.out::println);
	}

}

  Stream流的常见终结操作方法
   1. void forEach (Consumer action):对此流的每个元素执行操作

                Consumer接口中的方法void accept (T t):对给定的参数执行此操作

   2.long count ():返回此流中的元素数

package stream;

import java.util.ArrayList;

/*  Stream流的常见终结操作方法
 * 	1.void forEach (Consumer action):对此流的每个元素执行操作
	          Consumer接口中的方法void accept (T t):对给定的参数执行此操作
	2.long count ():返回此流中的元素数
 */
public class Streamdemo6 {
	public static void main(String[] args) {
	//创建一个集合，存储多个字符串元素
	ArrayList<String> list = new ArrayList<String>();
	list.add("林青霞");
	list.add("张曼玉");
	list.add("王祖贤");
	list.add("柳岩");
	list.add("张敏");
	list.add("张无忌");
	//需求1:把集合中的元素在控制台输出
	list.stream( ).forEach(System.out::println);
	//需求2:统计集合中有几个以张开头的元素，并把统计结果在控制台输出
	long count=list.stream().filter(s->s.startsWith("张")).count();
	System.out.println(count);
	}
}

 Stream流的练习
现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作●男演员只要名字为3个字的前三人
女演员只要姓林的，并且不要第一个
把过滤后的男演员姓名和女演员姓名合并到一起
把上一步操作后的元素作为构造方法的参数创建演员对象遍历数据
演员类Actor，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

演员类Actor:

package stream;

public class Actor {
   private String name;
   public Actor(String name) {
	   this.name=name;
   }
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
@Override
public String toString() {
	return name ;
}
   
}

具体实现的代码

package stream;

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

public class Streamdemo7 {

	public static void main(String[] args) {
		//创建集合
		ArrayList<String>manList = new ArrayList<String>();
		manList.add("周润发");
		manList.add("成龙");
		manList.add("刘德华");
		manList.add("吴京");
		manList.add("周星驰");
		manList.add("李连杰");
		ArrayList<String> womanList = new ArrayList<String>();
		womanList.add("林心如");
		womanList.add("张曼玉");
		womanList.add("林青霞");
		womanList.add("柳岩");
		womanList.add("林志玲");
		womanList.add("王祖贤");
        //男演员只要名字为前三个字的前三人
		Stream<String> sm=manList.stream().filter(s->s.length()==3).limit(3);
		//女演员只要姓林的，并且不要第一个
		Stream<String> sw=womanList.stream().filter(s->s.startsWith("林")).skip(1);
		//把过滤后的男演员姓名和女演员姓名合并到一起
		Stream<String> stream = Stream.concat(sm,sw);
		//把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
		stream.map(Actor::new).forEach(p->System.out.println(p.getName()));
		stream.map(Actor::new).forEach(System.out::println);//Actor方法里面要重写tostring方法

	}

}

Stream流的收集操作

对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢?

Stream流的收集方法
R collect(Collector collector)
但是这个收集方法的参数是一个Collector接口
工具类Collectors提供了具体的收集方式
public static <T> Collector toList():把元素收集到List集合中

public static <T> Collector toSet():把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中

package stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Streamdemo8 {

	public static void main(String[] args) {
		//创建List集合对象
		List<String>list = new ArrayList<String>();
		list.add("林青霞");
		list.add("张曼玉");
		list.add("王祖贤");
		list.add("柳岩");
		//需求1:得到名字为3个字的流
		Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
		//需求2:把使用stream流操作完毕的数据收集到List集合中并遍历
		List<String> names=listStream.collect(Collectors.toList());
		for(String name : names) {
		System.out.println(name);
		}		
		//创建set集合对象
		Set<Integer> set = new HashSet<Integer>();
		set.add(10);
		set.add(20);
		set.add(30);
		set.add(33);
		set.add(35);
		//需求3:得到年龄大于25的流
		Stream<Integer> setStream = set.stream().filter(age -> age > 25);
		//需求4:把使用Stream流操作完毕的数据收集到set集合中并遍历
		Set<Integer> ages = setStream.collect(Collectors.toSet());
		for(Integer age : ages) {
	    	System.out.println(age);
		}
		//定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
		String[] strArray ={"林青霞,33" ,"张曼玉,35","王祖贤,33","柳岩,25"};
		//需求5:得到字符串中年龄数据大于28的流
		Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1])> 28);
		//需求6:把使用stream流操作完毕的数据收集到map集合中并遍历，字符串中的姓名作键，年龄作值
		Map<String,Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0],s -> Integer.parseInt(s.split(",")[1])));
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
		Integer value = map.get(key);
		System.out.println(key + "," + value);
		}
	  }
	}