java 计算某个时间段在多个时间段中分别用时

已于 2023-02-13 09:44:51 修改
阅读量1.4k 收藏 7
点赞数 4
分类专栏： 算法 文章标签： java 开发语言
于 2022-11-15 11:35:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NOOBBB/article/details/127862244
版权
本文介绍了一个根据时间段不同收费的充电桩计费算法实现。通过校验和排序时间段，确定充电开始和结束时间所在时间段，然后计算每个时间段的充电时长。代码中包括对时间段的合法性检查、排序和计算充电总时长的逻辑。该算法适用于24小时制，处理了时间段首尾不相连的情况。
摘要由CSDN通过智能技术生成

最近碰到一个有趣的需求，花了一天时间写了代码实现。
需求：给汽车充电时，充电桩是会根据充电的时间段的不同来收费的，比如晚上用电高峰，这时充电会贵，凌晨没人用电，电费会便宜。大概就是分为尖、峰、平、谷四个类型，每个类型可能有多个时间段，那么，比如我充电一次，如何计算每个时间段内冲了多久的电呢？

大概逻辑：
1、对多个时间段进行校验，必须首尾相连
2、对时间段进行排序。找到最小的时间作为第一个，然后依照首尾进行排序
3、确定开始时间、结束时间所在的时间段，然后按照顺序遍历即可，中间的时间段就是满的。

需要注意的地方：
1、24小时制，所以总会有一个时间段是 结束时间小于开始时间
2、确定开始时间、结束时间所在的时间段时。例如开始时间8：00，那么它所属时间段应该是8:00-10:00,而不是6:00-8:00 ，同样，结束时间是8:00,那么它所属时间段应该是6:00-8:00，而不是8:00-10:00

代码如下：


import java.time.Duration;
import java.time.LocalTime;
import java.util.*;

/**
 * @author hph
 * @date 2022-11-14  10:52
 */
public class TimeSpanCalculateTest {
    public static void main(String[] args) throws Exception {
        HashMap<String, String> map = new HashMap<>();
        map.put("06:00-12:00", "尖");
        map.put("12:00-16:00", "峰");
        map.put("16:00-20:30", "平");
        map.put("20:30-00:00", "峰");
        map.put("00:00-06:00", "谷");

        String timeSpan = "00:00-08:10";
        checkTimeSpan(map);
        calculateTimeSpan(sortTimeSpan(map), timeSpan);

    }

    /**
     * 检查 时间段 格式是否正确
     * 1、小时、分钟都是两位 且 小时是0-23，分钟是0-59
     * 2、首尾相连
     * 3、共24小时
     *
     * @param map
     */
    private static void checkTimeSpan(HashMap<String, String> map) throws Exception {
        System.out.println("######## 开始 校验时间段#########");
        // 校验格式
        String regex = "([0-1]+[0-9]|2[0-3]):([0-5][0-9])-([0-1]+[0-9]|2[0-3]):([0-5][0-9])";
        for (String key : map.keySet()) {
            String[] tt = key.split("-");
            if (tt[0].equals(tt[1])) {
                throw new Exception("开始时间和结束时间不能相同");
            }
            if (!key.matches(regex)) {
                throw new Exception("时间段 格式错误");
            }
        }
        // 校验首尾相连
        // 以第一个为基准
        int foundSpan = 0;
        String span = "";
        String startSpan = "";
        String endSpan = "";
        int index = 0;
        // 最多循环map.keySet().size()次就能找到所有的
        // 缺点在于，如果一个时间段一直没找到下一个，还是会循环完，才会退出
        // 如何 循环一遍就退出整个循环呢
        // 变量太多，不想再加变量了，太乱
        for (int i = 0; i < map.keySet().size(); i++) {
            if (foundSpan == map.keySet().size()) {
                break;
            }
            // 没办法，还是加个变量吧
            int temp = 0 ;
            for (String value : map.keySet()) {
                String[] tt = value.split("-");
                // 第一次
                if (index == 0) {
                    span = tt[1];
                    startSpan = tt[0];
                    foundSpan++;
                    index++;
                }
                // 找到下一个时间段
                if (span.equals(tt[0])) {
                    foundSpan++;
                    span = tt[1];
                    // 最后一次
                    if (foundSpan == map.keySet().size()) {
                        endSpan = tt[1];
                    }
                    temp++;
                    continue;
                }

            }
            // 如果 一次循环，temp没有增加，那么就退出，不用再循环了
            if(temp == 0){
                break;
            }
        }
        if (foundSpan == map.keySet().size() && startSpan.equals(endSpan)) {
            System.out.println("######## 时间段 首尾相连#########");
        } else {
            System.err.println(String.format("找不到 %s 或 %s 的下一个时间段",span,startSpan));
            throw new Exception("时间段首尾不相连");
        }

        // 校验 是否是 24小时
        // 按理说 只要首尾相连了，那么肯定是24小时


    }

    private static void calculateTimeSpan(TreeMap<String, String> map, String timeSpan) {
        System.out.println("########开始计算#########");
        System.out.println("充电时间段：" + timeSpan);
        String startTime = timeSpan.substring(0, 5);
        String endTime = timeSpan.substring(6);

        String startSpan = "";
        String endSpan = "";

        for (String key : map.keySet()) {
            String span = map.get(key);
            if (isStartTimeInTimeSpan(startTime, span)) {
                startSpan = key;
            }
            if (isEndTimeInTimeSpan(endTime, span)) {
                endSpan = key;
            }
        }
        System.out.println("开始时间 时间段：" + startSpan);
        System.out.println("结束时间 时间段：" + endSpan);

        int totalTime = 0;
        for (String key : map.keySet()) {
            String span = map.get(key);
            int i = Integer.valueOf(key.substring(0, 1));
            int s = Integer.valueOf(startSpan.substring(0, 1));
            int e = Integer.valueOf(endSpan.substring(0, 1));
            // 开始时间 和 结束时间 是同一个时间段
            if(s == e){
                int minutes = calculateMinute(startTime, endTime);
                System.out.println(String.format("没有跨段 , 所属时间段：key: %s %s , 耗时（分钟）：%s", startSpan, map.get(startSpan), minutes));
                totalTime += minutes;
                break;
            }
            if (i == s) {
                int minutes = calculateMinute(startTime, span.substring(6));
                System.out.println(String.format("开始时间：%s  时间段：key: %s %s , 耗时（分钟）：%s", startTime, key, span, minutes));
                totalTime += minutes;
            }
            if (i == e) {
                int minutes = calculateMinute(span.substring(0, 5), endTime);
                System.out.println(String.format("结束时间：%s  时间段：key: %s %s , 耗时（分钟）：%s", endTime, key, span, minutes));
                totalTime += minutes;
            }
            if (i > s && i < e) {
                int minutes = calculateMinute(span.substring(0, 5), span.substring(6));
                System.out.println(String.format("中间时间  时间段：key: %s %s , 耗时（分钟）：%s", key, span, minutes));
                totalTime += minutes;
            }
            if (i < s || i > e) {
                continue;
            }
        }

        System.out.println("共用时：" + totalTime);
    }

    /**
     * 计算时间 段内的 分钟数
     *
     * @param s
     * @param e
     * @return
     */
    private static int calculateMinute(String s, String e) {
        int time1 = Integer.valueOf(s.substring(0, 2)) * 60 + Integer.valueOf(s.substring(3));
        int time2 = Integer.valueOf(e.substring(0, 2)) * 60 + Integer.valueOf(e.substring(3));
        if (time1 < time2) {
            return time2 - time1;
        } else {
            // 例如 23：00  到  01：00
            return 24 * 60 + time2 - time1;
        }

    }

    /**
     * 判断开始时间 是否在 某个时间段内
     *
     * @param t
     * @param span
     * @return
     */
    private static boolean isStartTimeInTimeSpan(String t, String span) {
        int time = Integer.valueOf(t.substring(0, 2)) * 60 + Integer.valueOf(t.substring(3));
        int time1 = Integer.valueOf(span.substring(0, 2)) * 60 + Integer.valueOf(span.substring(3, 5));
        int time2 = Integer.valueOf(span.substring(6, 8)) * 60 + Integer.valueOf(span.substring(9));
        if (time1 < time2) {
            // 例如 开始时间 8：00   时间段 8：00 - 12：00
            if (time >= time1 && time < time2) {
                return true;
            } else {
                return false;
            }
        } else {
            // 时间段 23：00 - 2：00   则只需判断开始时间大于 time1即可
            if (time >= time1 || time < time2) {
                return true;
            } else {
                return false;
            }
        }

    }

    /**
     * 判断结束时间 是否在 某个时间段内
     *
     * @param t
     * @param span
     * @return
     */
    private static boolean isEndTimeInTimeSpan(String t, String span) {
        int time = Integer.valueOf(t.substring(0, 2)) * 60 + Integer.valueOf(t.substring(3));
        int time1 = Integer.valueOf(span.substring(0, 2)) * 60 + Integer.valueOf(span.substring(3, 5));
        int time2 = Integer.valueOf(span.substring(6, 8)) * 60 + Integer.valueOf(span.substring(9));
        if (time1 < time2) {
            // 例如 结束时间 8：00   时间段 2：00 - 8：00
            if (time > time1 && time <= time2) {
                return true;
            } else {
                return false;
            }
        } else {
            // 时间段 23：00 - 2：00   则只需判断开始时间大于 time1即可
            if (time > time1 || time <= time2) {
                return true;
            } else {
                return false;
            }
        }

    }

    /**
     * 把时间段排序
     *
     * @param map
     * @return
     */
    private static TreeMap<String, String> sortTimeSpan(Map<String, String> map) {
        System.out.println("########开始排序#########");
        String minTime = "30";
        for (String key : map.keySet()) {
            String[] tt = key.split("-");
            if (minTime.compareTo(tt[0]) > 0) {
                minTime = tt[0];
            }
        }
        System.out.println(String.format("最小的开始时间：%s", minTime));

        TreeMap<String, String> map1 = new TreeMap<String, String>(new Comparator<String>() {
            public int compare(String a, String b) {
                return a.compareTo(b);
            }
        });
        int index = 0;
        // 最开始用的while true ，但是万一不首尾相连，就会找不到，所以改为for，万一找不到，最多循环map次，
        for (String test : map.keySet()) {
            if (map1.size() == map.size()) {
                break;
            } else {
                for (String key : map.keySet()) {
                    String value = map.get(key);
                    if (key.startsWith(minTime)) {
                        map1.put(index + "-" + value, key);
                        minTime = key.substring(6);
                        index++;
                    }
                }
            }
        }
        System.out.println("########排序后的结果#########");
        map1.keySet().stream().sorted();
        for (String key : map1.keySet()) {
            System.out.println(String.format("key: %s   value : %s", key, map1.get(key)));
        }
        return map1;
    }


}

结果：

######## 开始 校验时间段#########
######## 时间段 首尾相连#########
########开始排序#########
最小的开始时间：00:00
########排序后的结果#########
key: 0-谷   value : 00:00-06:00
key: 1-尖   value : 06:00-12:00
key: 2-峰   value : 12:00-16:00
key: 3-平   value : 16:00-20:30
key: 4-峰   value : 20:30-00:00
########开始计算#########
充电时间段：06:00-21:08
开始时间 时间段：1-尖
结束时间 时间段：4-峰
开始时间：06:00  时间段：key: 1-尖 06:00-12:00 , 耗时（分钟）：360
中间时间  时间段：key: 2-峰 12:00-16:00 , 耗时（分钟）：240
中间时间  时间段：key: 3-平 16:00-20:30 , 耗时（分钟）：270
结束时间：21:08  时间段：key: 4-峰 20:30-00:00 , 耗时（分钟）：38
共用时：908

总结：
1、已经很注意变量的命名了，可是有些变量真的不知道该怎么命名，比如tt
2、感觉算法还有很大提升空间，但这是我目前能想到的比较靠谱的了
3、代码太多if else，要是用python应该能好很多，java就这点不好
4、定义了太多变量，容易乱，比如校验首尾相连的时候，没有什么好的办法

有没有大佬能指教下？

说书人-
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java时间统计_java 按日期范围统计数据并填补缺失日期数据
weixin_39752157的博客
02-20 1013
1.情景展示如上图所示，按日期进行数据统计，我们知道，数据的来源肯定是数据库，一旦指定时间段，必然存在日期空缺的情况(也就是当天没有产生数据)除了使用SQL填补空缺日期记录外，有时我们不得不在java中做处理，填补空缺日期，并造当天的数据(最好还是使用SQL，实在实现不了再用java)这种情况也很常见，今天我们一起来看下，如何通过java填补空缺的数据，并返回给前端？2.解决方案/*** 开票统计...
JAVA实现按时间段查询数据操作
08-18
主要介绍了JAVA实现按时间段查询数据操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java计算机毕业设计智能充电桩(开题+源码+论文)
最新发布
qh602的博客
07-10 881
本研究内容将围绕智能充电桩系统的设计与开发展开，具体包括以下几个方面：一是用户管理模块的设计与实现，包括用户注册、登录、个人信息维护、余额查询与充值等功能，确保用户信息的安全性和便捷性；二是充电桩管理模块的开发，实现对充电桩的实时监控、状态更新、故障报警等功能，保障充电服务的稳定性和可靠性；四是取消预约功能的实现，允许用户在特定条件下取消已预约的充电时段，提高充电资源的灵活性；该系统不仅能够缓解充电难的问题，提高充电设施的利用率，还能通过预约机制有效分配充电时段，减少用户等待时间，提升充电体验。
java获取一个时间段内的时间
diangua0060的博客
09-14 742
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); Date dBegin = sdf.parse("2018-01-01"); Date dEnd = sdf.parse("2019-01-01"); List<String> datas = findDates(dBegin, ...
java判断当前时间是否在对应时间段内
weixin_45817985的博客
08-24 8683
java 8 新特性LocalDateTime
java时间差的百分之二十,java计算时间差及某个时间段数据
weixin_39892615的博客
03-10 160
最近在写代码的时候碰到一些关于处理时间的问题。总结了2个关于计算时间的代码。1、java算出时间差Date t1=dc.getComRegdate(); //从某个POJO拿出来的时间字段Date t2=new Date();long day=(t2.getTime()-t1.getTime())/(1000 * 60 * 60*24);//算出2个时间相差多少天2、hibernate+sprin...
手机厂Java高级工程师岗位面试真题
02-25
【Java高级工程师面试知识点】 1. **工作经历与项目经验**：面试中...以上知识点涵盖了Java高级工程师在面试中可能遇到的常见问题，涉及服务发现、负载均衡、服务容错等多个核心概念，是评估候选人技术能力的关键点。
java 使用简单的demo实例告诉你优化算法的强大
09-05
这个方法在处理大量数据时，速度远超循环累加，因为它只需要一次计算，无论n多大，执行时间几乎保持不变。 为了对比两种方法的性能，可以编写一个简单的测试Demo： ```java public static void main(String[] args...
java后端技术问题汇总（面试必看）
06-28
- **避免死锁**：死锁是因为多个线程互相等待对方释放资源导致的。避免死锁的方法包括避免循环等待、设置资源获取顺序等。 - **线程同步**：`wait()`和`sleep()`方法：`wait()`用于线程间通信，让线程释放对象锁并...
秒杀项目代码,秒刀房代码,Java
09-10
在这个Java秒杀项目中，我们主要关注的是如何利用Java技术栈来构建一个稳定、高效的秒杀系统。下面将详细讨论这个项目中涉及的技术和知识点。 1. **SSM框架**：SSM是Spring、Spring MVC和MyBatis的组合，是Java Web...
Java 判断一个时间是否在另一个时间段内
09-01
主要介绍了Java 判断一个时间是否在另一个时间段内的相关资料,需要的朋友可以参考下
Java计算一个时间段与当前时间的进度百分比
zmz200225的博客
10-09 2217
Date nowDate = new Date(); //当前时间 Date startDate = p.getPro().getStartDate(); //开始时间 Date endDate = p.getPro().getEndDate(); //结束时间 if (nowDate.getTime() <= startDate.getTime()) { //未开始项目进度设置为0 p.setTotalProgress(0L); } else if.
日期区间计算
张磊的专栏
09-18 1358
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load                Label1.Text = "今天是今年的第"        Label1.Text += DateDiff(DateInterval.Day, #1/1/
java 表示时间段_java--时间浅谈
weixin_36140403的博客
03-02 1196
最近一直忙着实习，整理了好多东西，可是一直都没有时间去写。今天分享的是关于java的时间函数。主要内容就是javaAPI中的时间类，和SQL中的时间函数。javaAPI中的时间类主要有：java.util.Date;java.sql.Date;java.util.Calendar'java.text.SimpleDateFormatjava.util.Date就是在除了SQL语句的情况下面使...
时间 java 时间段_java 时间范围
weixin_29609679的博客
02-12 555
if(isInTime("00:00-18:00", sd.format(new Date()))) {return Result.checkMsgFail("不在登记范围之内！");}public boolean isInTime(String sourceTime, String curTime) {if (sourceTime == null || !sourceTime.contains(...
JAVA 用时测试
peach_garden的博客
04-17 469
（1）以毫秒为单位的1. long startTime = System.currentTimeMillis(); // 获取开始时间  2.           3.         // doThing(); // 测试的代码段  4.           5.         long endTime = System.currentTimeMillis(); // 获取结束时间  6.  ...
java显示系统时间及判断时间段
weixin_42454225的博客
05-10 1289
在这里插入代码片 import java.text.SimpleDateFormat; public class ex_4 { public static void main(String[] args) { String time3; SimpleDateFormat time2=new SimpleDateFormat("HH"); //提取系统中的小时 i...
java 用时_JAVA一些常用的时间操作
weixin_39866265的博客
02-20 84
项目中经常有对时间进行处理的需求，下面是一些常用的操作整理，方便以后再次使用以及做相关复习。1.字符串转换为日期1 /**2 * 字符串转换为日期3 *@paramdateStr 需要转换的日期4 *@paramdateFormat 日期格式yyyy-MM-dd/yyyy-MM-dd HH:mm:ss5 */6 public static Date toDate(String ...
这个代码中相关的知识点讲解
06-08
这段代码是一个 Java GUI 程序，主要实现了一个基于 Swing 框架的小游戏，游戏的目标是用户需要在规定的时间内将显示在标签上的字符重新排列组合成正确的单词，并在文本框中输入答案。如果用户输入的答案正确，程序会弹出一个对话框提示用户答案正确，否则提示用户答案错误。此外，游戏还包含了计时器和计分器，用户需要在规定时间内尽可能多地猜对单词，游戏结束后会显示用户的得分和用时。 具体实现上，这段代码包含了以下几个方法： 1. `initComponents()`：初始化 GUI 组件，包括标签、文本框、按钮等。 2. `startButtonActionPerformed()`：点击“开始”按钮后触发的事件处理方法，随机生成一个单词并将其打乱，然后在标签上显示出来，同时启用“提交”按钮并禁用“开始”按钮，记录游戏开始时间。 3. `submitButtonActionPerformed()`：点击“提交”按钮后触发的事件处理方法，判断用户输入的答案是否正确，如果正确则弹出提示框并更新得分，否则弹出错误提示框。 4. `checkAnswer()`：判断用户输入的答案是否正确的方法，其中用到了 Java 的字符串比较方法 `equals()`。 5. `main()`：程序的入口方法，创建了一个 `WordGame` 对象并显示出来。 在实现过程中，涉及到的知识点包括 Java Swing GUI 编程、字符串操作、随机数生成、时间处理等。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值