JAVA8的新特性之Stream

JAVA8的新特性之Stream

1、概述：
在jdk1.8中，提供了一个Stream，可以对数据进行过滤
2、好处：
比不断自定义循环，要简单很多

Stream类型数据的获取

1、Collection 的获取
调用stream()方法，返回Stream类型的实现类对象
2、Map的获取，不能直接获取Stream类型
（1）keySet().stream();
(2)entrySet().stream();
3、数组的获取
Stream中的of方法，Stream.of(数组)

package com.ujiuye.demos;

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

public class Demo_7 {
//Stream类

	public static void main(String[] args) {
//		Collection集合获取Stream的方法
		Collection<String> coll = new ArrayList<>();
		coll.add("张飞");
		coll.add("张三丰");
		coll.add("张益达");
		coll.add("刘德华");
		coll.add("刘君如");
		coll.add("诸葛正我");
		coll.add("宫本武藏");
		coll.add("上官婉儿");
		System.out.println(coll);
		
		StringBuilder sb = new StringBuilder();
		sb.append(12).append(2);
		
//		调用stream方法
		Stream<String> stream = coll.stream();
		Stream<String> filter1 = stream.filter((x)->x.length()==3);
//		System.out.println(filter1);/
//		数组获取Stream对象
		int[] arr = {1,2,3,4,5,65};
		Stream<int[]> of = Stream.of(arr);
	}
}

Stream 中常用的方法

1、常用方法，都是对流中的数据，进行过滤，或者进行操作
2、分类：
（1）终结方法：调用完成之后，返回值不再是一个Stream的类型
forEach，count
（2）延迟方法：调用完之后，返回的还是一个Stream类型，可以继续调用Stream中的方法
除了终结方法，都是延迟方法
3、方法的罗列
Stream filter(Predicate pre)
根据pre描述的判断条件，对流中的数据进行截取
Stream limit(long maxSize)
根据参数maxSize描述的个数，对流中的数据进行截取
Stream skip(long n)
跳过参数n描述的个数，流中剩余的就是n之后的数
Stream map(Function<T,R> fun)
将流中T类型数据，通过fun这个函数的接口，将T类型的数据进行一系列的操作转成R类型的数据
long count();

package com.ujiuye.demos;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo_8 {
	public static void main(String[] args) {
//Stream中的常用方法
		Collection<String> coll = new ArrayList<>();
		coll.add("张飞");
		coll.add("张三丰");
		coll.add("张益达");
		coll.add("刘德华");
		coll.add("刘君如");
		coll.add("诸葛正我");
		coll.add("宫本武藏");
		coll.add("上官婉儿");
//		count
		System.out.println("--------count-----------");
		Stream<String> streamCount = coll.stream();
		long c = streamCount.count();
		System.out.println(c);
		
//		map
		System.out.println("------------map-----------------");
		Stream<String> streammap = coll.stream();
		Stream<String> streammap2 = streammap.filter((x) -> x.length() == 4);

//		
		List<Person> list = new ArrayList<>();
//将String类型的字符串，封装到Person类型
		Function<String, Person> fun = (x) -> {
			return new Person(x);
		};
//		forEach()方法的使用
		streammap2.map(fun).forEach((x) -> {
			list.add(x);
		});
		for (Person person : list) {
			System.out.println(person + " list");
		}

		
		System.out.println("----------skip---------------");
//		skip
		Stream<String> streamskip = coll.stream();
		streamskip.skip(4).forEach((x) -> System.out.println(x));

		System.out.println("------------------limit----------------");
//		limit
		Stream<String> streamlimit = coll.stream();
		streamlimit.limit(4).forEach(System.out::println);

		System.out.println("--------------filter-----------------");
//		filter
//		调用stream方法获取Stream类型的对象
		Stream<String> stream = coll.stream();
		Predicate<String> pre = (m) -> m.length() == 3;

		stream.filter((m) -> m.length() == 3).filter((m) -> m.startsWith("张")).forEach((x) -> System.out.println(x));

		/*Consumer<String> con = (x) -> System.out.println(x);
		Stream<String> stream1 = stream.filter(pre);
		Predicate<String> pre1  = (x)->x.startsWith("张");
		stream1.filter(pre1).forEach(con);*/
	}
}

有两个ArrayList，存储队伍中的多个成员名字，使用Stream方式，对以下步骤进行操作
1、第一个队伍中只要名字为3个字的成员姓名
2、第一个队伍只要筛选后的前三个人

3、第二个队伍只要姓张的
4、第二个队伍筛选之后不要前两个人

5、将两个队伍合并成一个队伍（使用Stream中的concat方法，学习使用）
6、合并之后的队伍中的所有人的Person（自定义类型）对象，存储到一个ArrayList集合中

队伍1：宫本武藏，宋公明，苏有朋，石头人，石传祥，李二，庄子，洪七公
队伍2：张三丰，赵伟伟，张自忠，铁木真，张天爱，张翠花

package com.ujiuye.demos;

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

public class Demo_9 {
	/*有两个ArrayList，存储队伍中的多个成员名字，使用Stream方式，对以下步骤进行操作
	1、第一个队伍中只要名字为3个字的成员姓名
	2、第一个队伍只要筛选后的前三个人
	
	
	3、第二个队伍只要姓张的
	4、第二个队伍筛选之后不要前两个人
	
	
	5、将两个队伍合并成一个队伍（使用Stream中的concat方法，学习使用）
	6、合并之后的队伍中的所有人的Person（自定义类型）对象，存储到一个ArrayList集合中
	
	
	队伍1：宫本武藏，宋公明，苏有朋，石头人，石传祥，李二，庄子，洪七公
	队伍2：张三丰，赵伟伟，张自忠，铁木真，张天爱，张翠花*/
	public static void main(String[] args) {
		String str1 = "宫本武藏，宋公明，苏有朋，石头人，石传祥，李二，庄子，洪七公";
		String str2 = "张三丰，赵伟伟，张自忠，铁木真，张天爱，张翠花";
		List<String> duiwu1 = getList(str1);
		List<String> duiwu2 = getList(str2);
//		转成流
		Stream<String> dw1Stream = duiwu1.stream().filter((x) -> x.length() == 3).limit(3);
//		第二个队伍
		Stream<String> dw2Stream = duiwu2.stream().filter((x) -> x.startsWith("张")).skip(2);
//		将两个队伍合并成一个队伍
		Stream<String> newStream = Stream.concat(dw1Stream, dw2Stream);
//		创建一个ArrayList集合用来存储Person对象
		ArrayList<Person> alist = new ArrayList<Person>();
//		将字符串类型转成Person类型
		Stream<Person> sp = newStream.map((x) -> {
			return new Person(x);
		});

		sp.forEach((x) -> alist.add(x));
		System.out.println(alist);

	}

//	分隔字符串，装入到集合中
	public static List<String> getList(String str) {
		List<String> list = new ArrayList<>();
		String[] strs = str.split("，");
		for (String string : strs) {
			list.add(string);
		}
		return list;
	}
}