java中的stream流部分用法及其他可能用到的方法

L_XiaoLing

已于 2024-06-07 16:15:53 修改

阅读量577

点赞数 17

文章标签： java

于 2024-06-04 17:54:48 首次发布

本文链接：https://blog.csdn.net/L_XiaoLing/article/details/139448062

版权

一、将String转换为List<Integer>

public List<Integer> stringChangeToListInt(String s) {
        if (StringUtils.isEmpty(s)) {
            return new ArrayList<>(0);
        }
        return Arrays.stream(s.split(",")).map(Integer::parseInt).distinct().collect(Collectors.toList());
    }

二、List<Map<String, 0bject>> 删除其中的某一值

使用迭代器删除，无法使用stream直接过滤

List<Map<String, Object>> coursesList = new ArrayList<>();
Iterator<Map<String, Object>> productsIterator = coursesList .iterator();
while (productsIterator.hasNext()) {
        // 删除特定元素
        Map<String, Object> product = productsIterator.next();
        int isShow = Integer.parseInt(String.valueOf(product.get("isShow")));
        if (Objects.isNull(product.get("courseName")) || isShow == 0) {
            productsIterator.remove();
        }
}

三、按中文首字母排序

1.List<Map<String, Object>>

Comparator comparator = Collator.getInstance(Locale.CHINA);
// 排序实现(按照老师名字首字母中文排序)
Collections.sort(result, (e1, e2) -> {
        return comparator.compare(e1.get("teacherName").toString(), e2.get("teacherName").toString());
});

2.List<String> titleList

List<String> titleList = titleSet.stream()
        // 名称排序（中文排序）
        .sorted((o1, o2) -> Collator.getInstance(Locale.CHINESE).compare(o1, o2))
        .collect(Collectors.toList());

四、java判断目标日期与当前日期之间相差的天数

    // 指定日期
    Date appointedTime = activityLessonVo.getActivityEndTime();
    // 获取当前日期时间
    Calendar current = Calendar.getInstance();
    Calendar target = Calendar.getInstance();
                    target.setTime(appointedTime);
    // 将时分秒,毫秒域清零--依需求以日期为界限计算相差天数，不清零时以时分秒进行计算，且不足24小时时算0天
                    target.set(Calendar.HOUR_OF_DAY, 0);
                    target.set(Calendar.MINUTE, 0);
                    target.set(Calendar.SECOND, 0);
                    target.set(Calendar.MILLISECOND, 0);
    // 判断目标日期与当前日期之间相差的天数
    long diffInMilly = target.getTime().getTime() - current.getTime().getTime();
    long timeDiff = TimeUnit.DAYS.convert(diffInMilly, TimeUnit.MILLISECONDS);
    System.out.println("目标日期与当前日期之间相差"+timeDiff );


// 计算两个时间分钟差
LocalDateTime dateNow = LocalDateTime.now();
LocalDateTime dateTime = LocalDateTime.ofInstant(startTime.toInstant(), ZoneId.systemDefault());
long timeDiff = ChronoUnit.MINUTES.between(dateNow, dateTime);

五、将一个List中的值通过某个字段赋值给另一个List

1.两个List对比取值，先转为map类型再做数据取值；使用get时确认一对一，最好使用getOrDefault。（以匹配年级对应的课程套餐为例）

// 以匹配年级对应的课程套餐为例  
    @Override
    public List<Map<String, Object>> listGroupCourses(OnlineCoursesRequestVo requestVo) {
        // 通过传入的查询全部课程的条件查询对应年级列表
        List<GradeResponseVo> grades = onlineAllCoursesMapper.listGrades(requestVo);
        List<Map<String, Object>> list = new ArrayList<>();
        // 查询对应的课程结果
        List<AllCoursesResponseVo> courseList = onlineAllCoursesMapper.listAllCourses(requestVo);
        if (CollUtil.isNotEmpty(courseList) && CollUtil.isNotEmpty(grades)) {
            // 此处为全部课程接口调用，通过课程结束时间去判断当前课程是否完结。同步课程，1999；完结课程，599。套餐中可能有多个课程，价格非固定，单个课程只有599和1999
            courseList.forEach(o -> o.setPrice(StringUtils.isEmpty(o.getEndTime()) ? 599d : (new Date().after(o.getEndTime()) ? 599d : 1999d)));
            // "LinkedHashMap::new, Collectors.toList()"避免对应List为空
            Map<Integer, List<AllCoursesResponseVo>> courseMap = courseList.stream().collect(Collectors.groupingBy(AllCoursesResponseVo::getFkGradeId, LinkedHashMap::new, Collectors.toList()));
            grades.forEach(g -> {
                List<AllCoursesResponseVo> coursesResponseVos = courseMap.getOrDefault(g.getGradeId(), new ArrayList<>(0));
                Map<String, Object> data = new LinkedHashMap<>();
                data.put("gradeId", g.getGradeId());
                data.put("gradeName", g.getGradeName());
                data.put("allCourses", coursesResponseVos);
                list.add(data);
            });
        }
        return list;
    }

六、重命名（String在List<Object>中如果有重名则返回新名字）

/**
 * 判断引用模板时是否存在相同的模板名字，存在返回不重复的新名字，不存在返回原来的名字（重命名）
 *
 * @param templateName 模板名字
 * @param templateList 同一个教学环节下的的模板集合
 * @return
 */
@Override
public String sameNameExists(String templateName, List<CeTemplate> templateList) {
    //如果同级下没有文件，不用改名，直接返回文件名字
    if (CollectionUtils.isEmpty(templateList)) {
        return templateName;
    }
    // 过滤当前目录文件集合获取到有相同名字的文件集合（未删除的文件）
    List<CeTemplate> equalsNameFiles = templateList.stream()
            .filter(obj -> templateName.equals(obj.getTemplateName()) && obj.getIsDelete() == 0)
            .collect(Collectors.toList());
    // 如果同级下不存在相同名字的文件，不用改名，直接返回文件名字
    if (CollectionUtils.isEmpty(equalsNameFiles)) {
        return templateName;
    }
    // 截取文件名（没有后缀的文件名称）
    String fileNameStr = templateName;
    // 文件名后缀
    String suffix = "";
    // 遍历当前目录文件集合，获取包含相同名字的名称集合（未删除的文件）
    String finalFileNameStr = fileNameStr;
    List<String> fileNames = templateList.stream()
            .filter(obj -> obj.getTemplateName().contains(finalFileNameStr) && obj.getIsDelete() == 0)
            .map(obj -> obj.getTemplateName())
            .collect(Collectors.toList());
    // 新名字
    String newFileName = null;
    //（）中的数字
    int nameIndex = 1;
    // 循环设置新名字，并判断新名字是否存在fileNames集合中，不存在返回新名字；存在nameIndex+1接着循环设置新名字
    while (newFileName == null) {
        //设置新名称
        String jointFileName = fileNameStr + "(" + nameIndex + ")" + suffix;
        if (!fileNames.contains(jointFileName)) {
            newFileName = jointFileName;
            continue;
        }
        nameIndex++;
        newFileName = null;
    }
    return newFileName;
}

七、将List<Object>转为Map<Integer, String>

Map<Integer, String> subjectMap = list.stream().collect(Collectors.toMap(Object::getInteger, Object::getString, (o1, o2) -> o1));

可将转换后的map进行对应需求数据取值

String str = subjectMap.getOrDefault(ObjectVo.getInteger(), "");

八、List中有关Double的计算，保留一位小数

Map<String, Double> valueMap = list.stream()
        .collect(Collectors.groupingBy(ObjectVo::getStringName,
                // 相同名字下的Double求和
                Collectors.summingDouble(ObjectVo::getScore)));
// 匹配名称相同下的Double值
List<String> titleList = new ArrayList<>();
List<Double> valueList = titleList.stream()
        .map(o -> valueMap.getOrDefault(o, -999.0))
        .collect(Collectors.toList());
Double totalScore = value.stream()
        .mapToDouble(ObjectVo::getScore)
        .sum();
DecimalFormat decimalFormat = new DecimalFormat();
// 保留一位小数
decimalFormat.setMaximumFractionDigits(1);
// 设置具体的进位机制
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
totalScore = Double.valueOf(decimalFormat.format(totalScore));

groupingBy：分组；
summingDouble：求和；
stream() .filter()：过滤；
stream().anyMatch()：判断的条件里，任意一个元素成功，返回true；
stream().allMatch()：判断条件里的元素，所有的都是，返回true;
stream().noneMatch()：与allMatch相反，判断条件里的元素，所有的都不是，返回true;

九、比较两个List<String>，取出两项中的不同项

// 查询名称组装并去重
List<String> projectNameList = list.stream()
                .map(ObjectVo::getStringName).distinct()
                .collect(Collectors.toList());
// 查询列表
List<Object> targetList = new ArrayList<>();
}});
List<String> differentTargetStrings = new ArrayList<>();
    if (!CollectionUtils.isEmpty(targetList)) {
    // 比较两个列表，取出不同列表
    List<String> targetNameList = targetList.stream().map(Object::getTargetName).collect(Collectors.toList());
    differentTargetStrings = projectNameList.stream()
            .filter(item -> !targetNameList.contains(item)).distinct()
            .collect(Collectors.toList());
}

十、时间格式回显转换

"2024-06-07T02:57:41.000+00:00"→"2024-06-07 10:57:41"

/**
 * CREATE_TIME：创建时间
 */
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime;

在对应的Date类型的字段上加上（String类型不用）：

@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")