Java计算下一次提醒时间的简单算法

最新推荐文章于 2023-03-02 16:02:30 发布
置顶 最新推荐文章于 2023-03-02 16:02:30 发布
阅读量931 收藏 3
点赞数 2
分类专栏： Java基础开发 Java算法 博彩算法 文章标签： Java 算法 推算提醒时间 工作日
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ltllml44/article/details/106057940
版权

Java计算下一次提醒时间的简单算法

需求分析

在生产实践过程中，我们接到了一个这样的需求，客户接到系统做工作单后，按照要求客服人员要定时进行回访，回访提醒必须在工作时间段内进行，提醒时间和工作时间客户要求自己设定。

算法分析

接到这个需求、首先进行分析得出了这样几个要素：

  1. 工作日 例如 2020-05-10 星期日(休) 2020-05-009 星期六 （法定工作日）
  2. 工作时段： 例如 08:30:00~12:00:00 这种时间段可能一天会设置多个
  3. 提醒间隔： 可以为10分钟，也可以为100分钟，跨过整个天，等等。
  4. 初始时间：初始时间可能是工作时间段内，也可能不在工作时间段内。
  5. 提醒时间： 减去非工作时间后得到在工作时间内的一个时间。

完成要素分析后，在找到对象与对象之间的关系，我们做一条时间轴，如下图所示。
时间轴
首先设置初始时间，通过分析可以得出初始时间有两种可能，第一种设置的初始时间在非工作时间段那么我们则以遇到的第一个时间段的开始时间作为有效的起点时间算，第二种设置的初始时间在工作时间内，有效的起点时间就是初始时间。同理，最终计算的提醒时间，也有两种可能，第一种是在工作时间内，第二种落点不在工作时间内。也就是说通过排列组合，满足四种判断便可以遍历掉所有可能性。
排列组合
结合需求，截止时间不在工作时间这个条件 是不被允许的，那么我们只要保证截止时间在工作时间内就好了，分析后最终结果为：

最终分析

由于减去工作时间在计算的是否颇为麻烦，所以算法做了一次变通：引入了一个倒计时计数器，时间间隔就是计数器的初始值，公式为
计数器时间= 倒计时剩余时间 - 工作时间
直到将计数器清零为止。这就是该程序的核心算法。这个算法在实践的时候还会等价转化（关注代码）

代码清单

核心算法

package com.xhd.demo;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import com.oracle.tools.packager.Log;

import java.util.Calendar;
import java.util.Date;

/**
 *
 * 机选下一次提醒时间
 * @ClassName CalculateTheNextReminderTime
 * @Description TODO
 * @Author 消魂钉
 * @Date 5/9 0009 21:58
 */
public class CalculateNextReminderTime {

    /**
     * 判断第一次情况 有两种  传入的时间不在工作区域内 和 传入的时间在工作区
     *                    下一次的时间也有两种情况 落点也有可能在工作区 和 不在工作区
     *                    这种程序递归算法为最佳选择。
     * @param date
     * @param times
     * @return
     */
    private static Timing firstStartTime(Date date,Integer times){
        //判断第一次时间是否在工作区之间

        boolean workingInterval = !WorkDayUtils.isWorkingInterval(date);
        Log.info("当前时间："+date+":"+workingInterval);
        if (workingInterval){
            //需要转移到下一个工作区间开始工作
            //不在工作区
            Timing startTiming = WorkDayUtils.nextWorkPeriod(date,WorkDayUtils.START_DATE_TYPE);
            //第一次确认时间不在工作区的剩余时间的算法: 下一个工作区开始时间
            startTiming.setTimeLeft(times*60*1000L);
            return startTiming;
        }else{
            //在工作区
            Timing startTiming = WorkDayUtils.nextWorkPeriod(date,WorkDayUtils.END_DATE_TYPE);
            Calendar calendar = DateUtil.calendar(startTiming.getEndDate());
            long endDateTimeLong = startTiming.getEndDate().getTime();
            //第一次确认时间在工作区的算剩余时间的算法: 下次提醒的时间 - (当前时间工作区截止时间 - 当前时间） = 剩余时间
            Long timeLeft=(endDateTimeLong - date.getTime())-(times*60*1000L);
            //将剩余时间放入Timing对象中
            if (timeLeft<0){
                //如果小于0 则证明下一次提醒在本区间内。
                startTiming = WorkDayUtils.nextWorkPeriod(startTiming.getEndDate(),WorkDayUtils.START_DATE_TYPE);
                startTiming.setTimeLeft(Math.abs(timeLeft));
            }else{
                startTiming.setTimeLeft(times*60*1000L);
                startTiming.setStartDate(date);
            }
            return startTiming;
        }
    }


    /**
     * 核心递归算法：思路 以计时器的倒计时TimeLeft 为 0 作为递归的结束条件
     * @param startTime
     */
    public static Timing getNextWorkTimeDomain(Timing startTime) {
        //核心算法公式  剩余时间 = 上次剩余时间 - 工作时间时间差（时间段结束时间 - 时间段结束时间）
        Long timeDiffer = Math.abs(startTime.getTimeLeft())-(startTime.getEndDate().getTime() - startTime.getStartDate().getTime());
        if(timeDiffer>0){
            Timing nextWorkPeriod = WorkDayUtils.nextWorkPeriod(startTime);
            nextWorkPeriod.setTimeLeft(timeDiffer);
            return getNextWorkTimeDomain(nextWorkPeriod);
        }
        return startTime;
    }

    /**
     *
     * @param startDate 开始时间
     * @param times 下次提醒时间
     * @return
     */
    public static String getNextReminderTime(Date startDate,Integer times){
        return WorkDayUtils.getReminderTime(getNextWorkTimeDomain(firstStartTime(startDate,times)));
    };


    //TDD  测试驱动开发
    public static void main(String[] args) {
        //设30分钟提醒一次
        Integer times = 30;

        Integer time2 = 5*60;

        //1.第一次确认时间 在工作时间  下一次提醒时间在工作时间
        Date parse1 = DateUtil.parse("2020-05-09 09:30:00");
        //1.第一次确认时间 在工作时间  下一次提醒时间在工作时间
        Date parse1a = DateUtil.parse("2020-05-09 09:31:00");
        //2.第一次确认时间 在工作时间 下一次提醒时间不在工作时间
        Date parse2 = DateUtil.parse("2020-05-09 11:50:00");
        //3.第一次确认时间 不在工作时间 下一次提醒时间在工作时间
        Date parse3 = DateUtil.parse("2020-05-09 12:40:00");
        //4.第一次确认时间 不在工作时间 下一次提醒时间不在工作时间
        Date parse4 = DateUtil.parse("2020-05-09 12:20:00");

        //5.第二次确认时间 在工作时间  下一次提醒时间在工作时间
        Date parse5 = DateUtil.parse("2020-05-09 10:00:00");
        //6.第二次确认时间 在工作时间 下一次提醒时间不在工作时间
        Date parse6 = DateUtil.parse("2020-05-09 16:55:00");


        //7.跨天数测试 在工作时间  下一次提醒时间在工作时间
        Date parse7 = DateUtil.parse("2020-05-09 21:50:00");
        //8.跨天数测试 在工作时间 下一次提醒时间不在工作时间
        Date parse8 = DateUtil.parse("2020-05-10 15:02:00");

        System.out.println("测试结果:");


        Assert.isTrue(getNextReminderTime(parse1,times).equals("2020-05-09 10:00:00"),"");
        Assert.isTrue(getNextReminderTime(parse1a,times).equals("2020-05-09 10:01:00"),"");
        Assert.isTrue(getNextReminderTime(parse2,times).equals("2020-05-09 13:20:00"),"");
        Assert.isTrue(getNextReminderTime(parse3,times).equals("2020-05-09 13:30:00"),"");



        Assert.isTrue(getNextReminderTime(parse1,time2).equals("2020-05-09 15:30:00"),"");
        Assert.isTrue(getNextReminderTime(parse1a,time2).equals("2020-05-09 15:31:00"),"");
        Assert.isTrue(getNextReminderTime(parse2,time2).equals("2020-05-09 18:50:00"),"");
        Assert.isTrue(getNextReminderTime(parse3,time2).equals("2020-05-09 19:00:00"),"");


    }
}

计数器对象

package com.xhd.demo;

import java.util.Date;

/**
 * @ClassName TimingObj
 * @Description TODO
 * @Author 消魂钉
 * @Date 5/9 0009 23:44
 */
public class Timing {

    /**
     * 计时器开始时间
     */
    private Date startDate;
    /**
     * 计时器结束时间
     */
    private Date endDate;
    /**
     * 计时器剩余时间
     */
    private Long timeLeft;


    public Timing(Date startDate, Date endDate, Long timeLeft) {
        this.startDate = startDate;
        this.endDate = endDate;
        this.timeLeft = timeLeft;
    }

    public Timing(Date startDate, Date endDate) {
        this.startDate = startDate;
        this.endDate = endDate;
    }

    public Date getStartDate() {
        return startDate;
    }

    public void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    public Long getTimeLeft() {
        return timeLeft;
    }

    public void setTimeLeft(Long timeLeft) {
        this.timeLeft = timeLeft;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }
}

工具类

package com.xhd.demo;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;

import java.util.*;

/**
 * @ClassName WorkDayUtils
 * @Description TODO
 * @Author 消魂钉
 * @Date 5/9 0009 21:36
 */
@Slf4j
public class WorkDayUtils {
    /**
     * 开始时间的下标
     */
    public static Integer START_DATE_TYPE = 0;
    /**
     * 结束时间的下标
     */
    public static Integer END_DATE_TYPE = 1;

    /**
     * 模拟工作时间段，可在Spring配置文件或者Mysql中读入
     * @return
     */
    public static List<String> getWorkPeriod() {
        List<String> period = new ArrayList<String>();
        period.add("08:00:00~12:00:00");
        period.add("13:00:00~17:00:00");
        period.add("18:00:00~22:00:00");
        return period;
    }

    //模拟节假日列表
    public static List<String> playday = new ArrayList<>();

    static {
        playday.add("2020-05-10");//假设是节假日
        playday.add("2020-05-12");//假设是节假日
        playday.add("2020-05-13");//假设是节假日
    }


    /**
     * 判断节假日
     *
     * @param date 传入的时间
     * @return true 表示 是节假日  false 表示不是节假日
     */
    public static boolean isPlayDay(Date date) {
        for (int i = 0; i < playday.size(); i++) {
        boolean b = compareTo(playday.get(i),DateUtil.formatDate(date));
        if (b){
            return b;
        }
    }
        return false;
}

    /**
     * 寻找非工作时段
     *
     * @param date 工作时间
     * @return true 是工作时段 false 不是工作时段
     */
    public static boolean isWorkPeriod(Date date) {
        long nowDate = date.getTime();
        String nowDateTime = DateUtil.format(date,DatePattern.NORM_DATE_FORMAT);
        List<String> workPeriod = getWorkPeriod();
        for (String s : workPeriod) {
            String[] split = s.split("~");
            log.info("isWorkPeriod方法中startTime:" + nowDateTime + " " + split[START_DATE_TYPE]);
            log.info("isWorkPeriod方法中endTime:" + nowDateTime + " " + split[END_DATE_TYPE]);
            long startTimeLong = DateUtil.parse(nowDateTime + " " + split[START_DATE_TYPE], DatePattern.NORM_DATETIME_PATTERN).getTime();
            long endTimeLong = DateUtil.parse(nowDateTime + " " + split[END_DATE_TYPE], DatePattern.NORM_DATETIME_PATTERN).getTime();
            if (startTimeLong <= nowDate && nowDate <= endTimeLong) {
                log.info("isWorkPeriod方法判断为:工作日");
                return true;
            }
        }
        log.info("isWorkPeriod方法判断为:非工作日");
        return false;
    }


    /**
     * 下一个时间在工作区内的情况     START_DATE_TYPE  END_DATE_TYPE
     *
     * @param date
     */
    public static Timing nextWorkPeriod(Date date,Integer dataType) {
        long nowDate = date.getTime();
        Map<Long, Timing> endTimeMap = getWorkPeriodList(date, getWorkPeriod(), END_DATE_TYPE);
        Set<Long> keySet = endTimeMap.keySet();
        Iterator<Long> iter = keySet.iterator();
        while (iter.hasNext()) {
            Long endTimeKey = iter.next();
            if (nowDate < endTimeKey) {
                Timing timing = endTimeMap.get(endTimeKey);
                return timing;
            }
        }
        return null;
    }


    /**
     * 获取是否在工作时间
     *
     * @param date
     * @return
     */
    public static boolean isWorkingInterval(Date date) {
        //先判断日期是否为工作日
        boolean workDay = !isPlayDay(date);
        log.info("isWorkingInterval方法的isPlayDay:"+workDay+"date:"+date);
        if (workDay) {
            //判断是否在工作时间段
            boolean workPeriod = isWorkPeriod(date);
            log.info("isWorkingInterval方法的isWorkPeriod:"+workPeriod+"date:"+date);
            if (workPeriod) {
                return true;
            }
        }
        return false;
    }

    //推算下一个工作日
    public static Date nextWorkDay(Date nextDate) {
        Calendar calendar = DateUtil.calendar(nextDate);
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        nextDate = DateUtil.date(calendar);
        boolean playDay = isPlayDay(DateUtil.date(calendar));
        if (playDay) {
           return nextWorkDay(nextDate);
        }
        return nextDate;
    }



    /**
     * 最近两天的列表：注意该演示程序只寻找了当天输入和下一个工作日的所有时间区间，
     *      *              如果提醒的间隔超过24小时以上，则需要获取更多的工作日区间
     * @param nowDate
     * @param workPeriod
     * @param dateType
     * @return
     */
    private static Map<Long, Timing> getWorkPeriodList(Date nowDate, List<String> workPeriod, Integer dateType) {

        List<String> dateList = new ArrayList<>();
        //传入的时间所在天的工作日情况
        if (isPlayDay(nowDate)){
            nowDate = nextWorkDay(nowDate);
        }
        dateList.add(DateUtil.format(nowDate, DatePattern.NORM_DATE_FORMAT));
        //增强边界 找到下一个工作日
        Date nextDate = nextWorkDay(nowDate);
        log.info("找到的下一个的工作日为:"+nextDate);
        dateList.add(DateUtil.format(nextDate, DatePattern.NORM_DATE_FORMAT));
        Map<Long, Timing> timeMap = new TreeMap<>(new Comparator<Long>() {
            @Override
            public int compare(Long o1, Long o2) {
                return o1.compareTo(o2);
            }
        });
        for (String dateStr : dateList) {
            for (String s : workPeriod) {
                String[] split = s.split("~");
                //只需要保存开始的时间，最好排序
                long startTimeLong = DateUtil.parse(dateStr + " " + split[START_DATE_TYPE], DatePattern.NORM_DATETIME_PATTERN).getTime();
                long endTimeLong = DateUtil.parse(dateStr + " " + split[END_DATE_TYPE], DatePattern.NORM_DATETIME_PATTERN).getTime();
                if (dateType.compareTo(START_DATE_TYPE) == 0) {
                    timeMap.put(startTimeLong, new Timing(DateUtil.date(startTimeLong), DateUtil.date(endTimeLong)));
                } else {
                    timeMap.put(endTimeLong, new Timing(DateUtil.date(startTimeLong), DateUtil.date(endTimeLong)));
                }
            }
        }
        return timeMap;
    }

    ;

    /**
     * 两个时间比对，相同则为true 不同为false
     * @param dateNew
     * @param dateOld
     * @return
     */
    public static boolean compareTo(String dateNew, String dateOld) {
        log.info("时间比较: "+dateNew+":"+dateOld+" 结果:"+dateNew.equalsIgnoreCase(dateOld));
        if (dateNew.equalsIgnoreCase(dateOld)){
            return true;
        }else{
            return false;
        }
    }


    public static void main(String[] args) {

        boolean b = compareTo("2020-05-12", "2020-05-11");
        System.out.println(b);
    }


    /**
     * 寻找到下一个工作区
     *
     * @param time
     * @return
     */
    public static Timing nextWorkPeriod(Timing time) {
        Long startDateLong = time.getStartDate().getTime();
        Map<Long, Timing> endTimeMap = getWorkPeriodList(time.getStartDate(), getWorkPeriod(), START_DATE_TYPE);
        Set<Map.Entry<Long, Timing>> entries = endTimeMap.entrySet();
        if (CollectionUtil.isNotEmpty(entries)) {
            Iterator<Map.Entry<Long, Timing>> iterator = entries.iterator();
            while (iterator.hasNext()) {
                Map.Entry<Long, Timing> next = iterator.next();
                if (startDateLong.compareTo(next.getKey()) == 0) {
                    Timing value = iterator.next().getValue();
                    log.info("nextWorkPeriod方法:" + value.getStartDate() + ":" + value.getEndDate());
                    return value;
                }
                ;
            }
        }
        return null;
    }

    /**
     * 通过递归算法推算到最后一个工作区间的开始时间 + 最后剩余的时间，算出来的就是最终需提醒的时间。
     * @param reminderTiming
     * @return
     */
    public static String getReminderTime(Timing reminderTiming) {
        long startTime = reminderTiming.getStartDate().getTime();
        Long reminderTimeLong = startTime+reminderTiming.getTimeLeft();
        String format = DateUtil.format(DateUtil.date(reminderTimeLong), DatePattern.NORM_DATETIME_FORMAT);
        return format;
    }
}

代码下载地址

代码下载地址

消魂钉
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 实现简单时间轮调度算法
qq_31587795的博客
09-16 423
public class TimeWheelTest3 { private ThreadPoolExecutor jobTriggerPool = new ThreadPoolExecutor(20, 50, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(50)); private Map<Integer, List<Integer>> ringData
Java编写简单计算器算法
大连海事大学_小天才的博客
04-14 851
Java编写简单计算器如何插入一段漂亮的代码片设定内容居中、居左、居右SmartyPantsUML 图表 (加抽象方法) 链接: link. 图片: 带尺寸的图片: 居中的图片: 居中并且带尺寸的图片: 当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。 如何插入一段漂亮的代码片 去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片. // An highligh...
java实现计算周期性提醒的示例
09-04
本文分享一个java实现计算周期性提醒的示例，可以计算父亲节、母亲节这样的节日，也可以定义如每月最好一个周五，以方便安排会议
java 时间提醒功能_Java怎么实现定时提醒功能
weixin_36477469的博客
02-13 2178
//可以启动一个线程来做时间计算//也可以用timer来实现定时 timer使用wait 我这里用sleep//关键不是用什么而是用线程来解决问题import java.util.Scanner;public class Test {public static void main(String[] args) {Runnable r = new Runnable() {final long sta...
御用导航官方网站提醒提示页_电脑上使用便签记录工作计划如何设置闹钟定时提醒？...
weixin_39859909的博客
10-25 1万+
平常工作日程事务比较多时，就很容易忘掉一些工作，这个时候很多工作族会选择经常使用的电脑工具来记录每日的工作计划，电脑如何设置闹钟定时提醒工作计划呢？电脑便签可以用来记录工作计划闹钟定时提醒的软件，建议使用敬业签。敬业签在电脑安装后，可以将工作计划一项项罗列清楚，并且针对不同的工作可以设置不同的分类，每一条工作计划均可设置闹钟定时提醒？下面给大家讲一下电脑上使用便签记录工作计划如何设置闹钟定时提醒呢...
安卓java类重复_系统日历 插入重复事件规则 (android/java)
weixin_36150816的博客
02-23 489
Recurrence Rule重复规则 rrule(Recurrence Rule) 属于 icalendar 属性中的一个，配合 dtstart 可以完整描述一个事件的重复行为并计算出重复事件的具体发生 (Occurence)。重复规则包含多个属性， 每个属性以 NAME = VALUE 对的形式存在， 属性与属性之间用分号区分， 属性之间没有特定的顺序要求，在同一个重复规则中每个属性最多只能出...
java处理重复的通知_制作仅在特定日期重复的本地通知
weixin_35604021的博客
02-25 152
我正在处理应用程序的本地通知，该应用程序应仅在特定日期触发并在该日重复，直到用户决定将其删除 . 每周三上午11:00发出一个示例通知 .当用户在时间选择器上按下完成时，将触发函数 - scheduleLocalNotification .var sundayNotification : UILocalNotification!var mondayNotification : UILocalNo...
java源码包---java 源码 大量 实例
04-18
　用JAVA开发的一个小型的目录监视系统，系统会每5秒自动扫描一次需要监视的目录，可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历,...
大姨妈计算
12-13
1. **日期和时间处理**：在"大姨妈计算"中，核心算法会涉及到日期对象的操作，比如计算两个日期之间的差值（月经周期），预测未来的日期（下一次月经预计时间）。Java提供了java.util.Date和java.time包，可以方便地...
YellowToteTracker:2015 年第一个发布的 Java 视觉跟踪系统
06-26
这个项目不仅是一个创新的应用实例，更是Java开发者们探索图像处理与视觉计算的一次重要尝试。 "YellowToteTracker"的主要目标是实现对特定对象——黄色手提包的实时追踪。这项技术的核心在于，通过复杂的算法分析...
JAVA上百实例源码以及开源项目
01-03
　用JAVA开发的一个小型的目录监视系统，系统会每5秒自动扫描一次需要监视的目录，可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历,...
java源码包2
04-20
　用JAVA开发的一个小型的目录监视系统，系统会每5秒自动扫描一次需要监视的目录，可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历...
redistemplate hash 过期时间_Java如何优雅的实现时间控制
weixin_39959236的博客
11-29 2759
前言：需求是这样的，在与第三方对接过程中，对方提供了token进行时效性验证，过一段时间token就会失效.后台有定时任务在获取，但是偶尔会出现token失效，这是因为在获取的时候，定时任务正在跑，可能正在获取最新的token中，这个时候如何过一段时间(比如800毫秒之后)再请求呢？小王仰望天空45度，思考起来了。。。一：时间控制的几种方案1.1: 从线程方面解决最简单粗暴的一种实现方案：Thre...
java 提醒小工具_【JAVA】一个简单的定时提醒小程序
weixin_39611331的博客
02-24 571
[Java] 纯文本查看 复制代码import javax.swing.JOptionPane;public class Test {public static void main(String[] args) {JOptionPane.showMessageDialog(null, "程序启动！");System.out.println("程序启动！");int setTime = setTim...
java倒计时器（定时任务）ps:我没摸鱼
最新发布
qq_60113473的博客
03-02 366
使用java定时任务编写的倒计时器
exchange创建邮箱组_网易企业邮箱日程管理功能升级，备受好评靠的是这些
weixin_39707725的博客
11-12 452
网易企业邮箱服务：400-0908-163。日程能帮我们有效的制定工作计划，同步会议安排，提升办公效率，是企业办公协同不可或缺的工具之一。然而多端日程不同步、跨国日程时间不同步、exchange协议日程不同步等问题也成为了办公人士们高效办公的“拦路虎”。网易企业邮箱近日推出日程管理升级版，有效解决了职场人士日常办公中日程管理上的痛点、痒点问题，成为又一极具竞争优势的亮眼产品。01 Webmail与...
17_juc
海涛帅帅的博客
09-14 430
Java JUC简介 在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。 volatile关键字-内存可见性 概述 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态，需要确保当一个
android 每天定时提醒功能实现
04-08 5698
android要实现定时的功能那肯定就要用到闹铃相关的技术， 那么android闹铃实现是基于 AlarmManager 这个类的，首先我们来看一下它的几个主要的方法。 打开AlarmManager的源码，如下图显示： 两个核心的方法 ：   Java代码   private final IAlarmManager mService;  
使用AmazeUI做的一个表单案例（验证）
热门推荐
销魂钉的专栏
07-27 1万+
微信开发，表单验证、AmazeUI、经典案例、图片压缩、JS、JavaScript、localResizeIMG
一维下料问题的遗传算法优化与应用
遗传算法是一种生物启发式的计算方法，它模仿自然选择和遗传机制来寻找解决问题的最优解。在解决一维下料问题时，这些问题通常涉及到如何有效地切割材料，以满足特定的尺寸和数量需求，同时最大化材料的利用率。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值