截取日期时间段，保证在一个时间线上

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量192 收藏
点赞数 3
分类专栏： 工具类 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzshen123456/article/details/136299428
版权

以前做HR时候由于是copy的sap hr的表结构，sap有定界的概念，定界根据时间约束来表示数据开始结束日期在表中什么样的，无交叉，无重叠，连续等。以前根据业务场景写，每个表都写了一遍，没有用泛型和反射去实现公用写法。现在从另一个角度来写，带有些许算法的味儿。

1.普通写法，声明一个TimeEntity,业务代码去复制给TimeEntity就好。然后都围绕这个TimeEntity实现。最后再处理相关业务。工具类都是普通的工具类，所以不在这里贴出来了。

根据各种场景截取日期时间段，得到自己想要的。看注释里就明白了。


import cn.hutool.json.JSONUtil;
import com.xhj.framework.web.common.DateUtils;
import com.xhj.framework.web.common.StringUtils;
import lombok.Data;

import java.io.Serializable;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class TestDate1 {
    public static void main(String[] args) throws ParseException {

        List<TimeEntity> list =new ArrayList<TimeEntity>();
//        //场景1  测试通过
//        |------|  |--------| 表数据(需要修改开始结束日期)
//            |----------|    前端返回带有开始结束日期点位置数据(需要保证整条完整)
        TimeEntity oldE = new TimeEntity();
        oldE.setId("1");
        oldE.setStartDate("2023-12-31");
        oldE.setEndDate("2024-02-10");

        list.add(oldE);

        TimeEntity oldE2 = new TimeEntity();
        oldE2.setId("2");
        oldE2.setStartDate("2024-02-11");
        oldE2.setEndDate("2028-12-01");
        list.add(oldE2);

        TimeEntity newE = new TimeEntity();
        newE.setId("");
        newE.setStartDate("2024-01-01");
        newE.setEndDate("2024-04-20");

        //场景2  测试通过
//        // |--------------|
//        //         |--------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-12-31");
//        oldE.setEndDate("2024-02-10");
//        list.add(oldE);
        //场景3  测试通过
//        //    |----------------|
//        //|---------|
//        TimeEntity oldE2 = new TimeEntity();
//        oldE2.setId("2");
//        oldE2.setStartDate("2024-02-11");
//        oldE2.setEndDate("2028-12-01");
//        list.add(oldE2);
        //场景4 测试通过
//        //  |--------------------|
//        //      |---------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-12-31");
//        oldE.setEndDate("2024-04-10");
//        list.add(oldE);

        //场景5
        //     |--------------|
        //  |--------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-12-31");
//        oldE.setEndDate("2024-04-10");
//        list.add(oldE);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-11-31");
//        newE.setEndDate("2024-04-20");

        //场景6   测试通过，返回无交叉不用处理数据
        // |----------|        |----------|
        //               |---|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity oldE1 = new TimeEntity();
//        oldE1.setId("2");
//        oldE1.setStartDate("2024-04-20");
//        oldE1.setEndDate("2024-11-10");
//        list.add(oldE1);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-11-31");
//        newE.setEndDate("2024-03-20");

        //场景7 通过
        //   |-------| |--------|
        // |-------------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity oldE1 = new TimeEntity();
//        oldE1.setId("2");
//        oldE1.setStartDate("2024-04-20");
//        oldE1.setEndDate("2024-11-10");
//        list.add(oldE1);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-09-30");
//        newE.setEndDate("2024-11-15");

        //场景8 通过
        //   |-------| |--------|
        //      |-------------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity oldE1 = new TimeEntity();
//        oldE1.setId("2");
//        oldE1.setStartDate("2023-12-20");
//        oldE1.setEndDate("2024-01-10");
//        list.add(oldE1);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-11-05");
//        newE.setEndDate("2024-11-15");

        //场景9 通过
        //   |-------| |--------|
        //      |-------------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity oldE1 = new TimeEntity();
//        oldE1.setId("2");
//        oldE1.setStartDate("2023-12-20");
//        oldE1.setEndDate("2024-01-10");
//        list.add(oldE1);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-09-05");
//        newE.setEndDate("2024-01-05");
        //场景10通过
        // |-------|  |---------|
        // |--------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity oldE1 = new TimeEntity();
//        oldE1.setId("2");
//        oldE1.setStartDate("2023-12-20");
//        oldE1.setEndDate("2024-01-10");
//        list.add(oldE1);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-10-31");
//        newE.setEndDate("2024-01-10");
        //场景11通过
        // |-------|  |---------|
        // |--------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity oldE1 = new TimeEntity();
//        oldE1.setId("2");
//        oldE1.setStartDate("2023-12-20");
//        oldE1.setEndDate("2024-01-10");
//        list.add(oldE1);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-11-01");
//        newE.setEndDate("2023-12-20");
        //场景12通过
        // |-------|
        //         |--------------------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-11-10");
//        newE.setEndDate("2023-12-20");

        //场景13通过
        //                   |-------|
        //         |---------|
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);
//
//        TimeEntity newE = new TimeEntity();
//        newE.setId("");
//        newE.setStartDate("2023-10-10");
//        newE.setEndDate("2023-10-31");

        getDates(list, newE);

    }
    public static List<TimeEntity> getDates(List<TimeEntity> oldEList, TimeEntity newE) throws ParseException {

        //即将插入日期 newE和数据库表数据有交叉
        boolean b = isOverlap(oldEList,newE);
        if(!b)
        {
            System.out.println("没有交叉，直接插入:" + JSONUtil.toJsonStr(newE));
            //插入数据库

            return new ArrayList<>();
        }

        //放到list排序
        List<TimeEntity> list = new ArrayList<>();

        list.add( new TimeEntity(newE.getId(),newE.getStartDate()));
        list.add( new TimeEntity(newE.getId(),newE.getEndDate()));

        for (TimeEntity oldEntity : oldEList) {

            list.add(new TimeEntity(oldEntity.getId(),oldEntity.getStartDate()));
            list.add(new TimeEntity(oldEntity.getId(), oldEntity.getEndDate()));
        }
        //去掉重复日期
        Map<String, TimeEntity> map = list.stream()
                .collect(Collectors.toMap(
                        TimeEntity::getDateStr,
                        Function.identity(),
                        (existing, replacement) -> StringUtils.isBlank(existing.getId()) ? existing : replacement
                ));

        List<TimeEntity> filteredList = new ArrayList<>(map.values());

        // 输出满足条件的 Entity 对象
        filteredList.forEach(System.out::println);

        list.clear();
        list.addAll(filteredList);
        list.sort(Comparator.comparing(TimeEntity::getDateStr));

        System.out.println("排序后的日期点：" + list);

        String newEStartDate = newE.getStartDate();
        String newEEndDate = newE.getEndDate();

        List<TimeEntity> dateRanges = new ArrayList<>();
        for (int i = 0; i < list.size()-1 ; i++) {
            TimeEntity dateVo = new TimeEntity();
            //  end > getDateStr >= start   分段，根据新老归属，划分id
            if(list.get(i).getDateStr().compareTo(newEStartDate)>=0&&list.get(i).getDateStr().compareTo(newEEndDate)<0){
                dateVo.setId(newE.getId());
            }else{
                if(!list.get(i).getId().equals(newE.getId())){
                    dateVo.setId(list.get(i).getId());
                }
                if(!list.get(i+1).getId().equals(newE.getId())){
                    dateVo.setId(list.get(i+1).getId());
                }
            }
            dateVo.setId(list.get(i).getId());
            // list.get(i)   is  new end point   +1
            if( list.get(i).getDateStr().equals(newEEndDate)){

                //+1天
                dateVo.setStartDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,DateUtils.addDays(DateUtils.parseDate(newEEndDate), 1)));
            }else{
                dateVo.setStartDate(list.get(i).getDateStr());
            }
            //         if    list.get(i+1) is  new end point   +0
            // else -1
            if( list.size() == i+2 || list.get(i+1).getDateStr().equals(newEEndDate)){
                dateVo.setEndDate(list.get(i+1).getDateStr());
            }else{
                //-1天
                dateVo.setEndDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,DateUtils.addDays(DateUtils.parseDate(list.get(i+1).getDateStr()), -1)));
            }
            dateRanges.add(dateVo);
        }

        System.out.println("按照时间分段数据: " + dateRanges);
        //去除和即将入库开始结束日期有交叉的数据
        dateRanges.removeIf(dateVo ->  dateVo.getStartDate().compareTo(newE.getEndDate())<=0
                && newE.getStartDate().compareTo(dateVo.getEndDate())<=0);
        dateRanges.add(newE);
        dateRanges.sort(Comparator.comparing(TimeEntity::getStartDate));
        System.out.println("最终数据数据: " + dateRanges);

        //对库操作

        return dateRanges;
    }

    public static boolean isOverlap(List<TimeEntity> timeEntityList, TimeEntity newEntity) {
        return timeEntityList.stream()
                .anyMatch(entity -> {
                    return entity.getStartDate().compareTo(newEntity.getEndDate())<=0 && newEntity.getStartDate().compareTo(entity.getEndDate())<=0;
                });
    }
    @Data
    public static class TimeEntity implements Serializable {
        String id;

        private  String dateStr;

        private String startDate;
        public TimeEntity(  ){

        }



        private String endDate;
        public TimeEntity(String id,String dateStr ){
            this.id=id;
            this.dateStr =dateStr;
        }
        public TimeEntity(String id,String startDate,String endDate ){
            this.id=id;
            this.startDate =startDate;
            this.endDate = endDate;
        }



    }
}

2.针对上边也可以用泛型+发射,来写一遍。TimeEntity在这里就相当于表对应的实体类。两种都可以，就看怎么处理业务数据。


import com.xhj.framework.web.common.DateUtils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class GenericEntityProcessor<T> {

    public List<T> getDates(List<T> oldEList, T newE) throws ParseException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        boolean b = isOverlap(oldEList, newE);
        if (!b) {
            System.out.println("No overlap, directly insert: " + newE.toString());
            return new ArrayList<>();
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        // Extracting fields using reflection
        Field idField = getField("id", newE.getClass());
        Field startDateField = getField("startDate", newE.getClass());
        Field endDateField = getField("endDate", newE.getClass());

        List<T> list = new ArrayList<>();
        list.add(createEntity(newE, idField, startDateField));
        list.add(createEntity(newE, idField, endDateField));

        for (T oldEntity : oldEList) {
            list.add(createEntity(oldEntity, idField, startDateField));
            list.add(createEntity(oldEntity, idField, endDateField));
        }

        // Remove duplicates based on the dateStr field
        Map<String, T> map = list.stream()
                .collect(Collectors.toMap(
                        entity -> (String) getFieldValue(entity, "dateStr"),
                        Function.identity(),
                        (existing, replacement) -> getFieldValue(existing, "id").equals("") ? existing : replacement
                ));

        List<T> filteredList = new ArrayList<>(map.values());
        filteredList.forEach(System.out::println);

        list.clear();
        list.addAll(filteredList);
        list.sort(Comparator.comparing(entity -> (String) getFieldValue(entity, "dateStr")));
        System.out.println("最终按照日期排序后的list: " + list);

        List<T> dateRanges = processDateRanges(list, newE);

        // Further processing and database operations
        return dateRanges;
    }

    public List<T> processDateRanges(List<T> list, T newE) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String newEStartDate = (String) getFieldValue(newE, "startDate");
        String newEEndDate = (String) getFieldValue(newE, "endDate");

        List<T> dateRanges = new ArrayList<>();
        for (int i = 0; i < list.size() - 1; i++) {
            T dateVo = createInstance(newE);

            String currentDateStr = (String) getFieldValue(list.get(i), "dateStr");
            String nextDateStr = (String) getFieldValue(list.get(i + 1), "dateStr");

            if (currentDateStr.compareTo(newEStartDate) >= 0 && currentDateStr.compareTo(newEEndDate) < 0) {
                setFieldValue(dateVo, "id", getFieldValue(newE, "id"));
            } else {
                if (!getFieldValue(list.get(i), "id").equals(getFieldValue(newE, "id"))) {
                    setFieldValue(dateVo, "id", getFieldValue(list.get(i), "id"));
                }
                if (!getFieldValue(list.get(i + 1), "id").equals(getFieldValue(newE, "id"))) {
                    setFieldValue(dateVo, "id", getFieldValue(list.get(i + 1), "id"));
                }
            }

            if (currentDateStr.equals(newEEndDate)) {
                //+1天
                setFieldValue(dateVo, "startDate", DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,DateUtils.addDays(DateUtils.parseDate(newEEndDate), 1)));
            } else {
                setFieldValue(dateVo, "startDate", currentDateStr);
            }

            if (list.size() == i + 2 || nextDateStr.equals(newEEndDate)) {
                setFieldValue(dateVo, "endDate", nextDateStr);
            } else {
                //-1天
                setFieldValue(dateVo, "endDate",DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,DateUtils.addDays(DateUtils.parseDate(nextDateStr), -1)));
            }

            dateRanges.add(dateVo);
        }

        System.out.println("按照时间分段数据: " + dateRanges);

        // Remove date ranges with overlap
        dateRanges.removeIf(dateVo -> {
            return ((String) getFieldValue(dateVo, "startDate")).compareTo(newEEndDate) <= 0
                    && newEStartDate.compareTo((String) getFieldValue(dateVo, "endDate")) <= 0;
        });

        dateRanges.add(newE);
        dateRanges.sort(Comparator.comparing(entity -> (String) getFieldValue(entity, "startDate")));
        return dateRanges;
    }

    public boolean isOverlap(List<T> entityList, T newEntity) throws IllegalAccessException {
        String newStartDate = (String) getFieldValue(newEntity, "startDate");
        String newEndDate = (String) getFieldValue(newEntity, "endDate");

        return entityList.stream()
                .anyMatch(entity -> {
                    return ((String) getFieldValue(entity, "startDate")).compareTo(newEndDate) <= 0 &&
                            newStartDate.compareTo((String) getFieldValue(entity, "endDate")) <= 0;
                });
    }

    private Field getField(String fieldName, Class<?> clazz) {
        try {
            return clazz.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
            return null;
        }
    }

    private Object getFieldValue(T entity, String fieldName) {
        try {
            Field field = entity.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(entity);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
    private void setFieldValue(T entity, String fieldName, Object value) {
        try {
            Field field = entity.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(entity, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private T createInstance(T entity) {
        try {
            return (T) entity.getClass().getConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    private T createEntity(T entity, Field idField, Field dateField) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        Object idValue = idField.get(entity);
        Object dateValue = dateField.get(entity);

        Constructor<?> constructor = entity.getClass().getConstructor(idField.getType(), dateField.getType());
        T newEntity = (T) constructor.newInstance(idValue, dateValue);

        return newEntity;
    }

    // Example of usage
    public static void main(String[] args) throws ParseException, InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException {
        List<TimeEntity> list = new ArrayList<>();
//        TimeEntity oldE = new TimeEntity();
//        oldE.setId("1");
//        oldE.setStartDate("2023-10-31");
//        oldE.setEndDate("2023-11-10");
//        list.add(oldE);

        TimeEntity oldE1 = new TimeEntity();
        oldE1.setId("2");
        oldE1.setStartDate("2024-04-20");
        oldE1.setEndDate("2024-11-10");
        list.add(oldE1);

        TimeEntity newE = new TimeEntity();
        newE.setId("");
        newE.setStartDate("2024-04-30");
        newE.setEndDate("2024-11-15");
        GenericEntityProcessor<TimeEntity> processor = new GenericEntityProcessor<>();
        List<TimeEntity> dateRanges = processor.getDates(list, newE);
        System.out.println("最终数据数据: " + dateRanges);
        // Further processing with the result
    }
}

两种写法最终实现截取时间段，联系不间断，无重叠。

最讨厌处理日期了......做个笔记记录下实现.

天天不想学习
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue怎么截取时间年月_时间格式的转化 vue与js 年月日 时分秒
weixin_39949776的博客
12-19 3280
首先使用原生转化的方法第一种//时间转换dateStr(d, sign) {//如果没有传递符号，给一个默认的符号if (!sign) {sign = '-'}//获取d里面年月日时分秒let year = d.getFullYear(),month = d.getMonth() + 1,sun = d.getDate(),hours = d.getHours(),minutes = d.getM...
【shell】shell脚本在大文件日志中按照时间段快速搜索日志
热门推荐
LZJing的专栏
05-06 1万+
问题描述： 在大流量线上服务中，日志系统会产生数量庞大的日志，动辄就是几十G。在如此之大的文件中快速搜索日志是运维人员经常遇见的问题。我们经常遇见的问题是查询一段时间内的某些条日志。比如，今天有一个访问失败了，大约是在上午9点，把这条日志找出来。查找失败原因。 常见处理方式及缺点： 1.如果文件比较小，100m以内使用grep、awk或者sed进行逐条匹配比较方便，但是文
如何获取两个时间段中重合的部分
Feify博客
05-14 6826
如何将两个时间段中重叠的部分给截取出来呢？ 如何将两个数字区间中重叠的部分给获取到？ 时间戳概念帮我们很好得解决这个问题，下面代码实现了具体的步骤
vue3+ts实现视频根据时间轴截取
wed2019的博客
09-22 2337
根据时间轴去手动设置起始时间和结束时间，控制视频的开始播放和结束播放时间
shell脚本在大文件日志中按照时间段快速搜索日志
aeoluspu的专栏
07-09 2961
问题描述：在大流量线上服务中，日志系统会产生数量庞大的日志，动辄就是几十G。在如此之大的文件中快速搜索日志是运维人员经常遇见的问题。我们经常遇见的问题是查询一段时间内的某些条日志。比如，今天有一个访问失败了，大约是在上午9点，把这条日志找出来，然后查找失败原因。常见处理方式及缺点：1.如果文件比较小，100m以内使用grep、awk或者sed进行逐条匹配比较方便，但是文件非常大时，其查找效率是非常...
java视频剪辑,截取视频指定时间段内容
12-08
本项目标题“java视频剪辑,截取视频指定时间段内容”表明这是一个使用Java语言实现的视频剪辑工具，能够帮助用户按照指定的时间段从原始视频中截取出子视频。这种功能对于个人用户进行视频编辑、内容筛选或教学材料...
mediacuttool一个Vue媒体多段裁剪工具
08-12
2. **时间轴操作**：通过时间轴展示，用户可以直观地看到视频的时间分布，并在时间线上进行精确的裁剪定位，确保每个剪辑的准确无误。 3. **预览功能**：在裁剪过程中，用户可以实时预览裁剪结果，避免因误操作导致...
视频截取软件
02-09
7. **多段截取**：除了单一的截取，有些软件还能让用户截取多个不连续的片段，并将它们合并成一个新文件。 8. **编辑功能**：部分视频截取软件会集成简单的编辑工具，如裁剪、旋转、调整亮度对比度等，方便用户在...
用于切取整首歌曲其中一段用工具
10-30
大部分工具会有一个时间线，你可以通过拖动或输入精确时间值来设定。同时，许多“切音工具”还具备预览功能，可以实时听到裁剪后的效果，确保满足你的需求。 接下来是保存环节。一旦确定了裁剪范围，软件会生成一个...
如何截取视频片段.docx
09-27
在这个界面中，你可以看到一个时间线，用于显示视频的播放进度。 3. 使用时间线上的滑块或输入框，设置“开始时间”和“结束时间”，来确定你要截取的视频片段的起止点。 4. 完成设置后，点击“确定”或“应用”按钮...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 419
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 770
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 558
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 255
android apk 加固后的地图加载异常及重新签名
Java学习_18_Stream流
qq_41136689的博客
08-23 1009
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 113
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
微服务框架
Founder_Xiao_Xin的博客
08-20 790
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
Java中队列和栈实现——基于集合
2301_80412275的博客
08-19 187
Queue是一个非常实用的接口，适用于许多需要顺序处理的场景，如任务调度、消息传递等。通过不同的实现类，可以根据需求选择合适的队列类型。
使用Java通过身份证号码匹配省市县名称的技术博客
weixin_41489908的博客
08-21 336
每日自动更新各类学习教程及工具下载合集​​在中国，身份证号码包含了持有人的出生地信息。通过解析身份证号码的前六位，我们可以获取对应的省、市、县（区）信息。在这篇博客中，我们将探讨如何使用Java代码来实现这一功能，并展示详细的代码示例和运行结果。
matlab，代码，一段音频曲线截取一段求这段的短时能量
06-13
好的，这个问题我可以回答。以下是 Matlab 代码实现： ```matlab % 读取音频文件 [y, fs] = audioread('...接着，我们使用一个循环计算每帧的短时能量，最后根据指定的时间段截取短时能量向量，并绘制短时能量曲线。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值