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

版权声明： 4000 https://blog.csdn.net/qq_35755863/article/details/91489715

一：基于stream的集合分组

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

[code]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的新特性。

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

[code]        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.遍历集合：依旧用上面的集合

 

[code]//传统实现遍历
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.按照某一个元素排序

[code]
//传统实现排序基于年龄
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.过滤掉某一些元素的

      

[code]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需要将数据转换成流，所以耗时较多，但是随着数据量越来越多，耗时差距越来越小。说明内部的结构操作是相同的。但是，其代码量大大的减少了。