最记载做到一个统计功能,发现其中的集合分组的实现,让人头疼。传统的分组方式,基于集合的遍历按照条件意义分组。如下例所示。 基于年龄的分组其实真的挺烦,即使我们使用工厂模式的话,他的代码量至少一个判断。
List userList=new ArrayList<>();
List 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 age15=new ArrayList();
if(user.getAge() == 15 ) {
age15.add(user);
}
List age16=new ArrayList();
if(user.getAge() == 16 ) {
age16.add(user);
}
List age17=new ArrayList();
if(user.getAge() == 17 ) {
age17.add(user);
}
}
基于此我百度发现网上有这么一种集合分组的方式:基于java8的stream的新特性。
还是上述集合。但是分组方式做改变:
Map> userGroupMap = list.stream().
collect(Collectors.groupingBy(User::getAge));
for(Map.Entry> 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)通过层次摸索,发现底层是迭代器??? 然后通过百度发现集合接口都是实现迭代器的接口。也就是说使用迭代器
针对集何操作少了很多子类的实现。
详情见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() {
@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 resList=new ArrayList();
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需要将数据转换成流,所以耗时较多,但是随着数据量越来越多,耗时差距越来越小。说明内部的结构操作是相同的。但是,其代码量大大的减少了。