java8新特性（1）-基于stream集合分组（包含stream对集合常用操作的功能）

一：基于stream的集合分组

最记载做到一个统计功能，发现其中的集合分组的实现，让人头疼。传统的分组方式，基于集合的遍历按照条件意义分组。如下例所示。基于年龄的分组其实真的挺烦，即使我们使用工厂模式的话，他的代码量至少一个判断。

List<User>  userList=new ArrayList<>();
		List<User> list = new ArrayList<>();
		User user1 = new User("1", "u1", 15);
		User user2 = new User("2", "u2", 15);
		User user3 = new User("2", "u3", 15);
		User user4 = new User("4", "u4", 16);
		User user5 = new User("5", "u5", 16);
		User user6 = new User("6", "u6", 16);
		User user7 = new User("7", "u7", 16);
		User user8 = new User("8", "u8", 17);
		User user9 = new User("9", "u9", 17);
		list.add(user1);
		list.add(user2);
		list.add(user3);
		list.add(user4);
		list.add(user5);
		list.add(user6);
		list.add(user7);
		list.add(user8);
		list.add(user9);
		
		//传统实现分组的方式（基于年龄）
		for(User user:list) {
			List<User> age15=new ArrayList<User>();
			if(user.getAge() == 15 ) {
				age15.add(user);
			}
			List<User> age16=new ArrayList<User>();
			if(user.getAge() == 16 ) {
				age16.add(user);
			}
			List<User> age17=new ArrayList<User>();
			if(user.getAge() == 17 ) {
				age17.add(user);
			}
		}

基于此我百度发现网上有这么一种集合分组的方式：基于java8的stream的新特性。

还是上述集合。但是分组方式做改变：

        Map<Integer,List<User>> userGroupMap = list.stream().  
				collect(Collectors.groupingBy(User::getAge));
		
for(Map.Entry<Integer, List<User>> e:userGroupMap.entrySet()) {
		System.out.println(e.getKey()+":"+e.getValue());
}

实际上，通过年龄分组转换成一个map。整个过程就是将list通过stream中的单个对象的方法来分组。

2.性能测试

在上述的方法中，我们来进行查看一下2者的运行时间。

第一次测试耗时（单位毫秒）

其他的耗时测试（单位毫秒）

经过多次测试发现稳定耗时（单位毫秒）：传统方式：1ms，stream方式：38ms（这是在9组测试数据下）

经过多次测试发现stream对万级别以上数据处理具有很大的优势。

3.瞅瞅底层

（1）使用stream需要先将list转化流。

（2）通过层次摸索，发现底层是迭代器？？？然后通过百度发现集合接口都是实现迭代器的接口。也就是说使用迭代器

针对集何操作少了很多子类的实现。

二.stream针对集合的一些其他的操作

详情见w3c教程：https://www.runoob.com/java/java8-streams.html

1.遍历集合：依旧用上面的集合

//传统实现遍历
	long date1=new Date().getTime();
	for(User user:list) {
		System.out.println(user.getUserName());
	}
	//基于stream
	long date2=new Date().getTime();
	list.stream().forEach(item->{
		System.out.println(item.getUserName());
	});

说明：性能差距不大，但是代码量大大的较少了

2.按照某一个元素排序


	//传统实现排序基于年龄
	long date1=new Date().getTime();
    Collections.sort(list, new Comparator<User>() {
		@Override
		public int compare(User o1, User o2) {
			if(o1.getAge() < o2.getAge()) {
				return 1;
			}
			
			if(o1.getAge() > o2.getAge()) {
				return -1;
			}
			
			if(o1.getAge() == o2.getAge()) {
				return 0;
			}
			return 0;
			
		}
    });
	
	
	//基于stream
	long date2=new Date().getTime();
	
	
	list = list.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList()); //倒叙
//	list = list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());   //正序
//这里区别于：list.sort((o1,o2)-> 02.getAge() -o1.getAge())

	long date3=new Date().getTime();
	
	System.out.println("共有"+list.size()+"组数据，倒叙排列用了"+(date2-date1)+"毫秒");
	System.out.println("共有"+list.size()+"组数据，倒叙排列用了"+(date3-date2)+"毫秒");
	
//	list.stream().forEach(item->{
//		System.out.println(item.getUserName());
//	});

说明：性能差距不大，但是代码量大大的较少了

3.过滤掉某一些元素的

int totalSize=list.size();
	
	//传统实现过滤（过滤掉年龄==15）
	long d1=new Date().getTime();
	List<User>  resList=new ArrayList<User>();
	for(User user:list) {
		if(user.getAge() !=15 ) {
			resList.add(user);
		}
	}
	long d2=new Date().getTime();	
	//基于stream
	list = list.stream().filter(o -> o.getAge() != 15 ).collect(Collectors.toList());
	long d3=new Date().getTime();
	System.out.println("共有"+totalSize+"组数据，倒叙排列用了"+(d2-d1)+"毫秒");
	System.out.println("共有"+totalSize+"组数据，倒叙排列用了"+(d3-d1)+"毫秒");

说明：性能差距不大，但是代码量大大的较少了

总结：

基于java8新特性的strem是基于集合转换成流来操作数据，在数据量较少时，由于stream需要将数据转换成流，所以耗时较多，但是随着数据量越来越多，耗时差距越来越小。说明内部的结构操作是相同的。但是，其代码量大大的减少了。