JDK1.8 集合常用操作

JDK1.8 常用集合操作
一.forEach操作

userTypeMaps.stream().forEach(p -> {
			userTypeMap.put(p.get("itemDesc"), p.get("itemValue"));
	});//userTypeMaps是List<Map<String, String>>的集合。根据key值找value

二.分组

// 把listdto跟进分中心进行排序分组
    Map<String, List<ManPowerConfigEntity>> maps = manPowerDataList.stream()
    .collect(Collectors.groupingBy(ManPowerConfigEntity::getArea));

三.排序后过滤

//以开始区间进行排序
	List<PartyAFloatRatioDto> rates = bankBusinessSortService.getPartyARankRato()
	rates.sort((u,m)->(u.getSortBegin()==null?"":u.getSortBegin()).compareTo(m.getSortBegin()==null?"":m.getSortBegin()));
    Optional<PartyAFloatRatioDto> findFirst = rates.stream().filter(u->"F".equals(u.getFirstOrLast())).findFirst();
    if (findFirst.isPresent()) {
       newList.add(findFirst.get());
    }

四.求最大值

ArrayList<CompilingRuleDto> compilingRuleList =xxoo;
	Optional<CompilingRuleDto> max = compilingRuleList.stream().max((u1,u2)->u1.getCompilingRateEnd().compareTo(u2.getCompilingRateEnd()));
    double doubleValue = max.get().getCompilingRateEnd().doubleValue();

五. list转为set

List<ManPowerConfigEntity> value =xxoo;
	Set<String> aset = value.stream().map(ManPowerConfigEntity::getAreaUM).collect(Collectors.toSet());

六.求和
求list中所有dto的age属性（integer/long类型）的总和
int total = list.stream().mapToInt(TaskStatistic::getAge).sum();

七.删除元素
删除list中dto为null的元素
list.removeAll(Collections.singleton(null));

八.综合使用

//按照有效月份,主业务线,业务分类分组
CompleteDtos.stream().collect(Collectors.groupingBy(CompleteRateDto::getIdKey)).values().forEach(p->{	
			StringBuilder errorInfo = new StringBuilder();
			//按照最小mob对集合排序
			Collections.sort(p,new Comparator<CompleteRateDto>(){
				/*
				 * int compare(CpmpleteDto o1, CpmpleteDto o2) 返回一个基本类型的整型，
				 * 返回负数表示：o1 小于o2，
				 * 返回0 表示：o1和o2相等，
				 * 返回正数表示：o1大于o2。
				 */
				@Override
				public int compare(CompleteRateDto o1, CompleteRateDto o2) {
					//按照最小mob升序排列
					if(o1.getMinMob() > o2.getMinMob()){
						return 1;
					}
					if(o1.getMinMob() == o2.getMinMob()){
						return 0;
					}
					return -1;
				}
			});
			//校验MOB重叠或不连续
			for(int i=1;i<p.size();i++) {
				if(p.get(i).getMinMob()>p.get(i-1).getMaxMob()) {//mob重叠
					errorInfo.append("业务线代码："+p.get(0).getBussinessCode()+",业务分类"+p.get(0).getBusssinessClassify()+"分组下催员MOB不连续;");
					break;
					//errorInfo.append("第"+(Integer.valueOf(p.get(i-1).getSeq())+1)+"行与第"+(Integer.valueOf(p.get(i).getSeq())+1)+"行MOB不连续;");
				}
				if(p.get(i).getMinMob()<p.get(i-1).getMaxMob()) {//mob不连续
					errorInfo.append("业务线代码："+p.get(0).getBussinessCode()+",业务分类"+p.get(0).getBusssinessClassify()+"分组下催员MOB重叠");
					break;
				//errorInfo.append("第"+(Integer.valueOf(p.get(i-1).getSeq())+1)+"行与第"+(Integer.valueOf(p.get(i).getSeq())+1)+"行MOB重叠;");
				}
		}
		String errorMessage = errorInfo.toString();
		if(StringUtils.isNotBlank(errorMessage)) {
			errorList.add(errorMessage);
		}
		});

七.1.8 forEach遍历是引用内部对象操作，属于一个封闭范围，怎么说呢如果代码块不加断点，debug时候工具会把forEach整体当作一句代码跑过，因此foreach应用时，内部代码不能把外部变量带入重新创建新对象；不能抛异常，只能try catch
性能对比：lambda的forEach循环在首次执行的时候会初始化部分内容，从而导致执行过慢，在后续的执行当中由于不需要再次进行初始化，所以才展现出真正的实力。

附：集合的浅复制与深复制
普通的集合复制只是将内存中栈的地址快拷贝一份，使得一个新的集合对象指向这个地址块，但是集合中的对象变量却是指向堆中的同一块区域。所以当拷贝的集合修改了集合对象内的数据，那么源集合对象也就随之改变了，这样的效果我们称之为Java集合对象的浅复制，即只是在栈中拷贝了，而堆中的数据并没有拷贝。而深度复制则是同时在栈中和堆中的数据进行拷贝，这样，其拷贝的集合和被拷贝的集合已经没有任何关系了。

实现深复制有两种方法，1，要复制的对象实现Cloneable接口。并重写克隆方法

public class Address implements Cloneable,Serializable{

private String address;
构造器1；
构造器2；
seter,geter方法
@Override
protected Object clone() {
    Address address = null;
    try {
        address = (Address) super.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    return address;
}

2.用spring的BeanUtils.copyProperties(dest,src)方法，一次只能拷贝一个bean

ArrayList<CompilingRuleDto> compilingRuleList =xxxx；
		List<CompilingRuleDto> grouplist = new ArrayList<>();
        //把compilingRuleList的开始和结束区间的数据封装到其他list的创建和更新字段里。然后进行分组，
        CompilingRuleDto swap;
        for (CompilingRuleDto dto : compilingRuleList) {
            swap = new CompilingRuleDto();
            BeanUtils.copyProperties(swap, dto);
            grouplist.add(swap);
        }
        grouplist.forEach(u->{
            u.setCreatedBy(String.valueOf(u.getCompilingRateBegin()));
            u.setUpdatedBy(String.valueOf(u.getCompilingRateEnd()));
        });

递归过滤

/**
 *  用递归的方式根据region维度，一层一层过滤数据
 * @param boardList 数据集
 * @param requetReiongs 过滤条件集合
 * @param size region维度
 * @return List<TaskBoardOverview> 过滤后的数据集
 */

private List<TaskBoardOverview> recursionFilterRegion(List<TaskBoardOverview> boardList, List<List<String>> requetReiongs, int size) {

    if (CollectionUtils.isEmpty(boardList)){
        return null;
    }
    List<TaskBoardOverview> swap;
    if (size == requetReiongs.size()){
        return boardList;
    }else{
        final int rank = size;
        List<String> filter = requetReiongs.get(size);
        if (CollectionUtils.isEmpty(filter)) {
            size = size +1;
            swap = recursionFilterRegion(boardList,requetReiongs,size);
        }else {
            swap = boardList.stream().filter(b -> {
                String split = b.getRegionGather().split(",")[rank];
                return filter.contains(split);
            }).collect(Collectors.toList());

            if (CollectionUtils.isEmpty(swap)) {
                return swap;
            }
            size = size + 1;
            swap = recursionFilterRegion(swap, requetReiongs, size);
        }
    }
    return swap;
}

树组装
/**
* 双层递归对象树组装
*
*
* @param regionStatistic
* @param boards 过滤集合
* @param filterReiongs region过滤条件
* @param projectName 项目名
* @param i 层级
* @param checkList 是否分组集合
* @param valueMap name和code的映射
* @return List
* @throws NoSuchFieldException 异常
* @throws IllegalAccessException 异常
*/
private void assembleTree(TaskStatistic regionStatistic, List boards, List<List> filterReiongs, String projectName, int i, List checkList, Map<String, String> valueMap) throws NoSuchFieldException, IllegalAccessException {

    if (CollectionUtils.isEmpty(boards)){
        return;
    }
    final int rank = i;
    int k = i + 1;
    if (i < filterReiongs.size()) {
        List<String> regionValue = filterReiongs.get(i);
        if (checkList.get(i) && ! CollectionUtils.isEmpty(regionValue)) {
            List<TaskStatistic> list = new ArrayList<>();
            for (String value : regionValue) {
                TaskStatistic levelDTO = new TaskStatistic();
                levelDTO.setProjectName(projectName);
                levelDTO.setRank(i + 3);
                levelDTO.setLevelCode(value);
                levelDTO.setDisplay(valueMap.get(value));
                List<TaskBoardOverview> swap = boards.stream().filter(b -> {
                    String split = b.getRegionGather().split(",")[rank];
                    return value.equals(split);
                }).collect(Collectors.toList());

                if (CollectionUtils.isEmpty(swap)){
                    continue ;
                }
                List<Map<String, Integer>> listMap = assemStatus(swap);
                assembleTree(levelDTO, swap, filterReiongs, projectName, k, checkList, valueMap);

                addStatusToDTO(listMap, levelDTO);
                list.add(levelDTO);
            }
            regionStatistic.setChildren(list);
        }else{
            i = i+1;
            assembleTree(regionStatistic, boards,filterReiongs,projectName,i,checkList, valueMap);
        }
    }

}