JDK1.8神器之stream流

Stream流的简单使用
- Stream流之过滤
- Stream流之去重
- Stream流之统计
- Stream流之求和
- - 对list中的值求和/平均数/最大值/最小值
  - 对list中对象的某个属性的值求和
- Stream流之获取平方
- Stream流之list 转为 Map
- Stream流之数据转换
- - Stream流之大小写转换
  - Stream流之转换数据类型
- Stream流之limit
- - Stream流之limit - 获取前 n 条数的数据
  - Stream流之limit - 结合 skip 使用得到需要的数据
- Stream流之排序sort
- - Stream流之随机取值排序
  - Stream流之优化排序==先获取在排序效率会更高!==
- Stream流之 groupingBy/partitioningBy 使用
- - Stream流之分组排序
  - Stream流之分区排序
- Stream 流之去重/最大值/最小值
- - Stream 流之最大值-max
  - Stream 流之最小值-min
  - Stream 流之去重-distinct

Stream流的简单使用

    在我们对项目优化的时候，除了代码的优化，SQL优化是必不可缺的，当我们为了性能把一些SQL  
的函数和一些逻辑去除之后，那么这时我们就需要在代码中去处理数据，在我自己日常工作中对数据
处理部分用Stream流还是比较多的，所以把自己日常用的一些小例子推荐给大家！

Stream流之过滤

// 过滤小例子
PropertyDescriptor nickName = Arrays.asList(Introspector.getBeanInfo(fieldClass).getPropertyDescriptors())
                                    .stream().filter(pro -> pro.getName().equals("nickName")).collect(Collectors.toList()).get(0);

Stream流之去重

// 去重小例子
List departmentList = userList.stream().map(User::getDepartment).distinct().collect(Collectors.toList());

Stream流之统计

// 统计小例子
Long ageNum = userList.stream().filter(user -> user.getAge() >= 28).count();
Long departNum = userList.stream().filter(user -> user.getDepartment() == "人事部").collect(Collectors.counting());
 //统计薪资大于3500元的人数
Long erNum= userList.stream().filter(user -> user.getSalary().compareTo(BigDecimal.valueOf(3500)) == 1).count();

Stream流之求和对list中的值求和/平均数/最大值/最小值

//对list中的值求和小例子
Map reasonMap = xxxMapper.countReason(requestxxxDTO);
//由于map中的value值都为Integer 所以这里我直接强转了，如果你所用的数据不是数值类型记着注意转换类型问题
List values = (List) reasonMap.values();
IntSummaryStatistics summaryStatistics = values.stream().mapToInt((s) -> s).summaryStatistics();

System.out.println("总条数：" + summaryStatistics.getSum());
System.out.println("平均数：" + summaryStatistics.getAverage());
System.out.println("总个数：" + summaryStatistics.getCount());
System.out.println("最大值：" + summaryStatistics.getMax());
System.out.println("最小值：" + summaryStatistics.getMin());

对list中对象的某个属性的值求和

//对list中的值求和小例子
List users = new ArrayList<>();
User user = new User();
user.setAge(18);
userList.add(user);
User user1 = new User();
user1.setAge(20);
userList.add(user1);
User user2 = new User();
user2.setAge(22);
userList.add(user2);
int ageSum = users.stream().collect(Collectors.summingInt(User::getAge));
System.out.println("所有用户年龄总和：" + ageSum);

Stream流之获取平方

//获取平方
List list = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
List list1 = list .stream().map(n -> n * n).collect(Collectors.toList());
System.out.println("平方的数据:" + list1 );

Stream流之list 转为 Map

//将list转为Map
List list = new ArrayList();  
list.add(new User("001", "小A"));  
list.add(new User("002", "小B"));  
list.add(new User("003", "小C"));

Map map = list.stream().collect(Collectors.toMap(User::getId, User::getName));

用Collectors的toMap方法转换List，一般会遇到两个问题。一个是转换map，key重复问题；另一个是空指针异常，即转为map的value是null。

Stream流之数据转换 Stream流之大小写转换

//大小写转换小例子
List list3 = Arrays.asList("hong", "lv", "hei");
System.out.println("转换前:" + list3);
List list4 = list3.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println("转换后:" + list4); 
转换后:[HONG,LV,HEI]

Stream流之转换数据类型

//数据类型转换小例子
List list = Arrays.asList("1", "2", "3");
System.out.println("转换前:" + list);
List list1 = list31.stream().map(Integer::valueOf).collect(Collectors.toList());
System.out.println("转换后:" + list1);

Stream流之limit

limit 方法用于获取指定数量的流。

Stream流之limit - 获取前 n 条数的数据

//获取前 n 条数的数据
Random rd = new Random();
System.out.println("取到的前n条数据:");
rd.ints().limit(n).forEach(System.out::println);

Stream流之limit - 结合 skip 使用得到需要的数据

skip 表示的是扔掉前 n 个元素。

//结合 skip 使用得到需要的数据
List list9 = new ArrayList();

for (int i = 1; i < 4; i++) {
    User user = new User(i, "pancm" + i);
    list9.add(user);
}
System.out.println("截取之前的数据:");
// 取前3条数据，但是扔掉了前面的2条，可以理解为拿到的数据为 2<=i<3 (i 是数值下标)
List list10 = list9.stream().map(User::getName).limit(3).skip(2).collect(Collectors.toList());
System.out.println("截取之后的数据:" + list10);

Stream流之排序sort Stream流之随机取值排序

//随机取值排序小例子
Random rd = new Random();
System.out.println("取到的前三条数据然后进行排序:");
rd.ints().limit(3).sorted().forEach(System.out::println);
//取到的前三条数据然后进行排序:
//-20434563
//-17785957
//10133695

Stream流之优化排序先获取在排序效率会更高!

//优化排序小例子 
//普通的排序取值
List list11 = list9.stream().sorted((u1, u2) -> u1.getName().compareTo(u2.getName())).limit(3)
        .collect(Collectors.toList());
System.out.println("排序之后的数据:" + list11);
//优化排序取值
List list12 = list9.stream().limit(3).sorted((u1, u2) -> u1.getName().compareTo(u2.getName()))
        .collect(Collectors.toList());
System.out.println("优化排序之后的数据:" + list12);
//排序之后的数据:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]
//优化排序之后的数据:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]

Stream流之 groupingBy/partitioningBy 使用 Stream流之分组排序

 //分组排序小例子
System.out.println("通过id进行分组排序:");
Map> personGroups = Stream.generate(new UserSupplier2()).limit(5)
        .collect(Collectors.groupingBy(User::getId));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry> persons = (Map.Entry) it.next();
    System.out.println("id " + persons.getKey() + " = " + persons.getValue());
}

//通过id进行分组排序:
//id 10 = [{"id":10,"name":"pancm1"}]    
//id 11 = [{"id":11,"name":"pancm3"}, {"id":11,"name":"pancm6"}, {"id":11,"name":"pancm4"}, {"id":11,"name":"pancm7"}]

class UserSupplier2 implements Supplier {
    private int index = 10;
    private Random random = new Random();

    @Override
    public User get() {
        return new User(index % 2 == 0 ? index++ : index, "pancm" + random.nextInt(10));
    }
}

Stream流之分区排序

// 分区排序小例子
System.out.println("通过年龄进行分区排序:");
Map> children = Stream.generate(new UserSupplier3()).limit(5)
        .collect(Collectors.partitioningBy(p -> p.getId() < 18));

System.out.println("儿童: " + children.get(true));
System.out.println("成人: " + children.get(false));

// 通过年龄进行分区排序:
// 儿童: [{"id":16,"name":"xx"}, {"id":17,"name":"yy"}]
// 成人: [{"id":18,"name":"xs"}, {"id":19,"name":"xa"}, {"id":20,"name":"xz"}]

 class UserSupplier3 implements Supplier {
    private int index = 16;
    private Random random = new Random();

    @Override
    public User get() {
        return new User(index++, "pancm" + random.nextInt(10));
    }
}

Stream 流之去重/最大值/最小值 Stream 流之最大值-max

// 获取list中最大值小例子
//最长字符的长度String::length
int maxLines = list13.stream().mapToInt(String::length).max().getAsInt();

Stream 流之最小值-min

// 获取list中最小值小例子
//最小字符的长度String::length
int maxLines = list13.stream().mapToInt(String::length).min().getAsInt();

Stream 流之去重-distinct

// 对list数据去重小例子
String lines = "good good study day day up";
List list14 = new ArrayList();
list14.add(lines);
List words = list14.stream().flatMap(line -> Stream.of(line.split(" "))).filter(word -> word.length() > 0)
        .map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());
System.out.println("去重复之后:" + words);

 总结的不算太全，但是工作中需要的应该差不多全了，如果有需要没有，可以私信我。
 谢谢大家

JDK1.8神器之stream流

Java相关栏目本月热门文章