JAVA学习（一）java8的stream方法

lambda表达式、集合的stream()方法

一、集合

1.List

List<SysUser> list
-----转Lis<String>
List names = list.stream().map(StatisticsDto::getName).collect(Collectors.toList());
或List names = list.stream().map(e->e.getName()).collect(Collectors.toList());
-----转Set<String>
Set names = list.stream().map(StatisticsDto::getName).collect(Collectors.toSet());
-----转Map
Map<String,Integer> map = list.stream().collect(Collectors.toMap(StatisticsDto::getName, StatisticsDto::getAge));
Map<String,SysUser> map = list.stream().collect(Collectors.toMap(StatisticsDto::getName, item->item));
Map<String,List<SysUser>>> map = list.stream().collect(Collectors.groupingBy(StatisticsDto::getName));

Collectors.toMap时注意：
1、key不能有重复，否则会报错，因为Map的key不能重复
2、value不能为空，否则报空指针，对应处理：
list.stream().collect(HashMap::new,(m, v)->m.put(v.getName(), v.getAddress()), HashMap::putAll);

2.Map

//Map转List
Set mapSet = map.entrySet();
List list= mapSet.stream().map(e -> {
    StatisticsDto statisticsDto = new StatisticsDto();
    statisticsDto.setName(e.getKey());
    statisticsDto.setValue(e.getValue());
    return statisticsDto;
}).collect(Collectors.toList());
或
List stringList = mapSet.stream().map(e -> e.getKey() + " " + e.getValue()).collect(Collectors.toList());

//(s, a) -> a)表示两个输入参数（一个相同的key对应的两个value），返回后一个值
Map classifyIdNameMap = serveTypeDtoList.stream().collect(Collectors.toMap(ServeTypeDto::getServeClassifyId, ServeTypeDto::getServeClassifyName, (s, a) -> a, LinkedHashMap::new));

//分组后顺序不变
Map map = list.stream().collect(Collectors.groupingBy(SzjjHnPilot::getType, LinkedHashMap::new, Collectors.toList()));

//循环
map.forEach((k,v)->{})

3.过滤filter

获取"女孩"所有对象，需要返回接收，并且不会影响原list
List newList = list.stream().filter(item -> item.getName().equals("女孩")).collect(Collectors.toList());

filter得出的结果可能会为空null，则可以这样处理：
List dataList = Optional.ofNullable(list.stream().filter(list.stream().filter(item -> item.getName().equals("女孩")).collect(Collectors.toList())).orElse(new ArrayList<>());
----->现在不会了，如果没有数据会返回空集合，而不是null

4.去重

List newList = list.stream().distinct().collect(Collectors.toList());
List newList = list.stream().map(StatisticsDto::getName).distinct().collect(Collectors.toList());

对不同对象，根据对象的某个属性去重：
普通写法：
Map map = list1.stream().collect(Collectors.toMap(UserEntity::getName, item->item));
Set list1Set = list1.stream().map(UserEntity::getName).collect(Collectors.toSet());
Set list2Set = list2.stream().map(UserEntity::getName).collect(Collectors.toSet());
//list1，移除list2中元素（根据name）
list1Set .removeAll(list2Set);
list1.clear();
for(String str : list1Set){
    list1.add(map.get(str));
}

lambda表达式写法：
Set list2Set = list2.stream().map(item2 ->item2.geName()).collect(Collectors.toSet());
list1 = list1.stream().filter(item-> !list2.stream().map(item2 ->item2.geName()).collect(Collectors.toSet()).contains(item.geName())).collect(Collectors.toList());

5.最大值、最小值

BigDecimal maxValue = list.stream().map(StatisticsDto::getValue).max(Comparator.naturalOrder()).orElse(BigDecimal.ZERO);
BigDecimal maxValue = list.stream().map(StatisticsDto::getValue).min(Comparator.naturalOrder()).orElse(BigDecimal.ZERO);
orElse() 当结果为空时会执行

6.分组

List list
Map map1 = list.stream().collect(Collectors.groupingBy(StatisticsDto::getName));
Map map2 = list.stream().collect(Collectors.groupingBy(e->e.getName()));

分组后顺序不变：
Map classifyIdTypeMap = serveTypeDtoList.stream().collect(Collectors.groupingBy(ServeTypeDto::getServeClassifyId,LinkedHashMap::new, Collectors.toList()));
LinkedHashMap indexIdMap = v.stream().collect(LinkedHashMap::new,(map, item) -> map.put(item.getId(), item),Map::putAll);

7.跳出循环

lambda表达式、集合的stream()方法：
    跳过本次循环 return;
普通for循环：
    跳过本次循环 continue
    跳过所有循环 break;
    跳出多层循环 break loop;
loop:
for(){
    for(){
    	break loop;
    }
}

8.排序

//普通写法：
按照集合的对象元素的某个属性降序
private void listSort(List list){
    Collections.sort(list, new Comparator() {
        @Override
        public int compare(ApiStatisticsDto o1, ApiStatisticsDto o2) {
        	return o2.getOtherCount().compareTo(o1.getOtherCount());
        }
    });
}
升序：


//java8写法：需要接收的
根据TestDto对象的priority字段降序
dtoList = dtoList.sort(Comparator.comparing(TestDto::getPriority).reversed());

升序
dtoList = dtoList.sort(Comparator.comparing(TestDto::getSort));

升序时，属性值为空排后面
dtoList = dtoList.sort(Comparator.comparing(ImportantIndustryInfo::getDataPullGrowth, Comparator.nullsLast(BigDecimal::compareTo)));

按照指定顺序排序
List sortList = Arrays.asList("aaa", "bbb");
List orderTypeList = typeList.stream().sorted(Comparator.comparing(sortList::indexOf)).collect(Collectors.toList());

排序时，值为空会报错，对应处理：
Map industryDataMap = queryList.stream().collect(LinkedHashMap::new, (m, v)->m.put(v.getIndustryName(), v.getData()), LinkedHashMap::putAll); //如上面Collectors.toMap时写法
DataDto dataDto = CollectionUtils.isEmpty(list) ? null : list.stream().sorted(Comparator.comparing(DataDto::getT).reversed()).findFirst().get();

按照多个字段排序，比如标签升序、数据值降序：
Comparator comparator = Comparator.comparing(Industry200ResultDataDto::getRuleSort).thenComparing(Industry200ResultDataDto::getDataValue).reversed();
cityLabelDataList = cityLabelDataList.stream().sorted(comparator).collect(Collectors.toList());

9.求和

BigDecimal industryTotalScore = list.stream().reduce(BigDecimal.ZERO, BigDecimal::add);  //BigDecimal.ZERO：当list中没有元素的时候就默认返回0

10.统计list中对象的重复次数

Map map = list.stream().collect(Collectors.groupingBy(p -> p,Collectors.counting()));
map.forEach((k, v) -> System.out.println(k + ":" + v));

11.Optional处理null的问题

User userById = Optional.ofNullable(xxx).orElse(new User());

二、数组

int[] 转List
//java8写法
int[] arrays = new int[]{1,2};
List list = Arrays.stream(arrays).boxed().collect(Collectors.toList());