1. 数据去重

①stream流去重(本质还是使用treeset)

public static List<UserBean> handleRepeatByStream(List<UserBean> userBeanList){
        if (userBeanList == null || userBeanList.size() == 0){
            return userBeanList;
        }
        return userBeanList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(UserBean::getName))) ,ArrayList::new));
    }

②HashMap去重(利用hashMap的key值不能重复来对list去重)

public static List<UserBean> handleRepeatByHashMap(List<UserBean> userBeanList){
        
        if (userBeanList == null || userBeanList.size() == 0){
            return userBeanList;
        }
        Map<String, UserBean> map = new HashMap<>();
        ArrayList<UserBean> list = new ArrayList<>();

        userBeanList.forEach(userBean -> map.put(userBean.getName(), userBean));
        map.forEach((s,userBean) -> list.add(userBean));
        return list;
    }

③TreeSet去重(利用set集合不可重复来对list去重)

public static List<UserBean> handleRepeatByTreeset(List<UserBean> userBeanList){

        if (userBeanList == null || userBeanList.size() == 0){
            return userBeanList;
        }

        Set<UserBean> set = new TreeSet<>(new Comparator<UserBean>() {
            @Override
            public int compare(UserBean o1, UserBean o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        set.addAll(userBeanList);
        return new ArrayList<>(set);
    }

2. 数据过滤

①使用stream流中的filter进行过滤

    public void filterByStream(List<UserBean> userList){
        userList = userList.stream().filter(userBean -> userBean.getAge() > 18).collect(Collectors.toList());
    }

②根据迭代器进行过滤

    public void filterByInterator(List<UserBean> userList){
        List<UserBean> newUserBeanList = new ArrayList<>();
        Iterator<UserBean> iterator = userList.iterator();
        while (iterator.hasNext()){
            UserBean userBean = iterator.next();
            if (userBean.getAge() > 18){
                newUserBeanList.add(userBean);
            }
        }
    }

3. 数据排序

①使用comparator比较器进行排序

 public void sortByComparator(List<UserBean> userList){
        Collections.sort(userList, new Comparator<UserBean>() {
            @Override
            public int compare(UserBean o1, UserBean o2) {
                return o1.getAge - o2.getAge;
            }
        });

②通过实现comparable接口进行排序(被比较的对象的类需要实现comparable接口并重写compareTo方法)

public void sortByComparable(List<UserBean> userList){
        Collections.sort(userList);
    }

③使用stream流中的sort进行排序

public void sortByStream(List<UserBean> userList){
        userList = userList.stream().sorted(Comparator.comparing(UserBean::getAge)).collect(Collectors.toList());
    }

4. 数据分组

①Map集合分组

public Map<String, List<Grade>> groupByMap(List<Grade> gradeList){
        Map<String, List<Grade>> map = new HashMap<>();
        for (Grade grade : gradeList) {
            if (!map.containsKey(grade.getClassName())){
                ArrayList<Grade> list = new ArrayList<>();
                list.add(grade);
                map.put(grade.getClassName(),list);
            }else{
                map.get(grade.getClassName()).add(grade);
            }
        }
        return map;
    }

②stream流分组

public Map<String,List<Grade>> groupByStream(List<Grade> gradeList) {
        HashMap<String, List<Grade>> map = new HashMap<>();
        return gradeList.stream().filter(Objects::nonNull)
                .collect(Collectors.groupingBy(Grade::getClassName));
    }

5. 处理空指针异常

① if判断处理npe

//使用if判断的缺点是：嵌套太深，代码阅读性差 
public String getCountryByIf(User user){
    if (user != null) {
        Company company = user.getCompany();
        if (company != null){
            Address address = company.getAddress();
            if (address != null){
                String country = address.getCountry();
                return country;
            }
        }
    }
    return null;
}

② jdk8中的Optional类处理npe

private String optionalGetCountry(User user) {
    return Optional.ofNullable(user)
            .map(User::getCompany)
            .map(Company::getAddress)
            .map(Address::getCountry)
            .orElse(getCountry());       
}

③使用spring框架的assert断言处理

private String assertGetCountry(User user) {
    Assert.notNull(user, "用户不能为空");
    Company company = user.getCompany();
    Assert.notNull(company, "公司不能为空");
    Address address = company.getAddress();
    Assert.notNull(address,"地址不能为空");
    String country = address.getCountry();
    return country;
}

6. Stream流使用Filter,Sort,GroupBy,Average,Sum操作List

Stream流处理数据的过程：

1. 源头：将源数据转换为Stream流对象

2. 管道：将Stream流对象进行处理，包括过滤、排序、分组，并且返回一个Stream流对象

2. 终点：最后对Stream流对象进行遍历、收集、统计等操作

①Stream流处理list集合---Filter

public List<Grade>  filterByStream(List<Grade> gradeList){
    return gradeList.stream()
            .filter(Objects::nonNull)
            .filter(grade -> grade.getEnglishScore() > 81)
            .collect(Collectors.toList());
}

②Stream流处理list集合---Sort

public List<Grade> sortByStream(List<Grade> gradeList) {
  return gradeList.stream()
          .filter(Objects::nonNull)
          .sorted(Comparator.comparing(Grade ::getChineseScore))
          .collect(Collectors.toList());
}

③Stream流处理list集合---GroupBy

public Map<String,List<Grade>> groupByStream(List<Grade> gradeList) {
        return gradeList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(Grade::getSlassName));
    }

④Stream流处理list集合---Average

public Double averageByStream(List<Grade> gradeList) {
    return gradeList.stream()
            .filter(Objects::nonNull)
            .mapToInt(Grade::getChineseScore)
            .average()
            .orElseThrow(IllegalAccessError::new);
}

⑤Stream流处理list集合---Sum

public Integer sumBySteam(List<Grade> gradeList){
    return gradeList.stream()
            .filter(Objects::nonNull)
            .mapToInt(Grade::getChineseScore)
            .sum();
}