精华内容
下载资源
问答
  • 通过给定的固定的时间段,输出在该时间段内固定间隔的每时刻的List集合,如果最后的时间间隔不够的话,将结束时间作为最后的时刻。 /** * 获取固定间隔时刻集合 * @param start 开始时间 * @param end ...

    通过给定的固定的时间段,输出在该时间段内固定间隔的每个时刻的List集合,如果最后的时间间隔不够的话,将结束时间作为最后的时刻。

     

     

     /**
         * 获取固定间隔时刻集合
         * @param start 开始时间
         * @param end 结束时间
         * @param interval 时间间隔(单位:分钟)
         * @return
         */
        public static List<String> getIntervalTimeList(String start,String end,int interval){
            Date startDate = DateTimeUtils.convertString2Date("HH:mm:ss",start);
            Date endDate = DateTimeUtils.convertString2Date("HH:mm:ss",end);
            List<String> list = new ArrayList<>();
            while(startDate.getTime()<=endDate.getTime()){
               list.add(DateTimeUtils.convertDate2String("HH:mm:ss",startDate));
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(startDate);
                calendar.add(Calendar.MINUTE,interval);
                if(calendar.getTime().getTime()>endDate.getTime()){
                    if(!startDate.equals(endDate)){
                       list.add(DateTimeUtils.convertDate2String("HH:mm:ss",endDate));
                    }
                    startDate = calendar.getTime();
                }else{
                    startDate = calendar.getTime();
                }
    
            }
            return list;
        }

     

    该方法中用到的字符串转日期的方法:convertStringDate

    public class DateUtils {
        public static Date convertString2Date(String format, String dateStr) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
            try {
                Date date = simpleDateFormat.parse(dateStr);
                return date;
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static void main(String[] args) {
            System.out.println(convertString2Date("HH:mm:ss","19:00:00"));
        }
    }

     

    该方法中用到的日期转字符串的方法:convertDate2String

    package cn.jiguang.ad.example.unittesting.util;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class DateUtils {
    
        public static String convertDate2String(String format,Date date) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
            return simpleDateFormat.format(date);
        }
    
        public static void main(String[] args) {
            System.out.println(convertDate2String("HH:mm:ss",new Date()));
        }
    }
    

     

    测试方法:

     

    List<String> list = DateTimeUtils.getIntervalTimeList("12:00:00","20:30:00",60);
            for (String s : list) {
                System.out.println(s);
            }

     

     

     

     

     

    测试结果:

     

     

     

    将时间按照5分钟的间隔拆分到不同的数组中,提供一种简陋的解决思路,具体方法可根据具体情况做进一步的优化

    public static void main(String[] args) {
            String[] dateArr = {"11:01", "11:02", "11:03", "11:06", "11:10", "11:15", "11:20", "23: 40"};
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");
            Map<Integer, List<String>> map = new HashMap<>();
            for (int i = 0; i <= 25; i ++) {
                map.put(i, new ArrayList<>());
            }
            Map<String, Integer> minuteMap = new HashMap<>();
            for (String s : dateArr) {
                try {
                    Date date = simpleDateFormat.parse(s);
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(date);
                    int hour = calendar.get(Calendar.HOUR_OF_DAY);
                    List<String> sss = map.get(hour);
                    sss.add(s);
                    map.put(hour, sss);
                    System.out.println(s + ": hour: " + hour);
                    int min = calendar.get(Calendar.MINUTE);
                    System.out.println(s + ": minute: " + min);
                    minuteMap.put(s, min);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(map);
            Map<String, List<String>> kkk = new HashMap<>();
            for (Integer integer : map.keySet()) {
                List<String> list = map.get(integer);
                for (String s : list) {
                    Integer minute = minuteMap.get(s);
                    if (minute == 0) {
                        List<String> t = kkk.get(integer + "-0");
                        if (t == null) {
                            t = new ArrayList<>();
                        }
                        t.add(s);
                        kkk.put(integer + "-0", t);
                    } else {
                        int n = minute % 60;
                        if (n > 0 && n <= 5) {
                            List<String> t = kkk.get(integer + "-0");
                            if (t == null) {
                                t = new ArrayList<>();
                            }
                            t.add(s);
                            kkk.put(integer + "-0", t);
                        } else if ( n >5 && n <= 10 ) {
                            List<String> t = kkk.get(integer + "-1");
                            if (t == null) {
                                t = new ArrayList<>();
                            }
                            t.add(s);
                            kkk.put(integer + "-1", t);
                        } else if ( n >10 && n <= 15 ) {
                            List<String> t = kkk.get(integer + "-2");
                            if (t == null) {
                                t = new ArrayList<>();
                            }
                            t.add(s);
                            kkk.put(integer + "-2", t);
                        } else if ( n >15 && n <= 20 ) {
                            List<String> t = kkk.get(integer + "-3");
                            if (t == null) {
                                t = new ArrayList<>();
                            }
                            t.add(s);
                            kkk.put(integer + "-3", t);
                        } else if ( n >20 && n <= 25 ) {
                            List<String> t = kkk.get(integer + "-4");
                            if (t == null) {
                                t = new ArrayList<>();
                            }
                            t.add(s);
                            kkk.put(integer + "-4", t);
                        }
                    }
                }
            }
        }

     

    展开全文
  • 0900-1200 1200-1600 1600-2100 2100-0900 这四个时间段 意思就是相当于一天的开始是9点,然后最后的时间段是晚上9点到第二天早上9点 ,查询的数据都是9点到第二天9点的数据,求大神给点思路
  • 最近写项目,遇到一个将选中时间段平均分割为若干小段,然后根据小段时间在数据库查询求均值的问题,后台大哥犯懒,非说后台做不了,让我分好传给他ヾ(。 ̄□ ̄)ツ゜゜゜好气呦,但还要保持微笑,我就是这么懂礼貌的...

    最近写项目,遇到一个将选中时间段平均分割为若干小段,然后根据小段时间在数据库查询求均值的问题,后台大哥犯懒,非说后台做不了,让我分好传给他ヾ(。 ̄□ ̄)ツ゜゜゜好气呦,但还要保持微笑,我就是这么懂礼貌的好孩子ー( ̄~ ̄)ξ

     

    闲话不多说,来说实现过程

    最开始只是分固定时间段,每天两小时一分,也就直接全写了,后来需求变了,日期选择输入,想要多少天就要多少天,时间大了要求取到的数据量还是那么多

    我:不太好实现啊老板

    boss:啥?别人都能做到,你咋就做不到?你这技术水平怕是有点低了把?

    我:那我试试(MDZZ)

    先确定后台需要什么数据格式,按照存入格式,先写个方法

    1 function range(beginTime, endTime) {//存入格式
    2     this.beginTime = beginTime;
    3     this.endTime = endTime;
    4 }

    考虑到这是一个js文件,数据分割也是固定的等分,就写一个从外部获取参数的函数吧,TimeRange(startTime,endTime)函数用来供页面调用,只传入开始时间,结束时间,不写分多少组了,因为需要的数据总量一般都是固定的,分多少组也是固定的,哪里需要直接来js改就好了

    1  function TimeRange(startTime, endTime) { //传入开始时间var startTime 传入结束时间var endTime 传入格式xxxx-xx-xx 年月日
    2     var amount = 100; //定义分多少组
    3     var startTimes = startTime + " 00:00:00"; //日期添加时分秒 开始日期
    4     var endTimes = endTime + " 23:59:59"; //日期添加时分秒 结束日期
    5

     

    判断一波

    复制代码
    1 if(endTimes <= startTimes) {
    2         alert('结束日期必须大于开始日期!');
    3         return -1;
    4     }
    5 
    6     if(dataDiff > 15) {
    7         alert('单次查询日期不超过两周,请重新选择!');
    8         return -2;
    9     }
    复制代码

    既然平均分,那就得知道时间间隔,计算时间间隔,写个方法直接调用

    复制代码
     1 //计算天数差的函数,通用
     2 function DateDiff(sDate1, sDate2) { //sDate1和sDate2是2006-12-18格式  
     3     var aDate, oDate1, oDate2, iDays
     4     aDate = sDate1.split("-")
     5     oDate1 = new Date(aDate[1] + '-' + aDate[2] + '-' + aDate[0]) //转换为12-18-2006格式  
     6     aDate = sDate2.split("-")
     7     oDate2 = new Date(aDate[1] + '-' + aDate[2] + '-' + aDate[0])
     8     iDays = parseInt(Math.abs(oDate1 - oDate2) / 1000 / 60 / 60 / 24) //把相差的毫秒数转换为天数  
     9     return iDays
    10 }
    复制代码

     

    整理了一下逻辑,伪代码如下

    复制代码
     1     //计算时间段总时间,分割后每段时间间隔,单位(秒)
     2         var timeRange;//存储计算出的时间段
     3         var timeAll ; //总时间间隔
     4         var timeGap ; //分割后时间间隔
     5         var slidingTime = 0; //循环开始条件
     6         var momentTime_front; //时间段前一个值
     7         var momentTime_rear;//时间段后一个值
     8         for(slidingTime; slidingTime < timeAll; slidingTime += timeGap) {
     9             momentTime_front = 计算出的时间前半部分
    10             momentTime_rear = 计算出的时间后半部分
    11             timeRange.push(new range(momentTime_front, momentTime_rear));//将计算后的小段的开始时间和结束时间组合存入timeRange
    12         }
    13         return timeRange;
    14     } 
    复制代码

     

     

    实现后的TimeRange()方法如下:

    复制代码
     1 function TimeRange(startTime, endTime) { //传入开始时间var startTime 传入结束时间var endTime
     2     var amount = 100; //定义分多少组
     3     var timeRange = new Array(); //return数组初始化
     4     var dataDiff = DateDiff(startTime, endTime); //计算两个日期相差天数
     5     var startTimes = startTime + " 00:00:00"; //日期添加时分秒 开始日期
     6     var endTimes = endTime + " 23:59:59"; //日期添加时分秒 结束日期
     7 
     8     if(endTimes <= startTimes) {
     9         alert('结束日期必须大于开始日期!');
    10         return -1;
    11     }
    12 
    13     if(dataDiff > 15) {
    14         alert('单次查询日期不超过两周,请重新选择!');
    15         return -2;
    16     }
    17     if(1) {
    18         //计算时间段总时间,分割后每段时间间隔,单位(秒)
    19         var timeAll = (dataDiff + 1) * 24 * 3600; //总时间间隔
    20         var timeGap = timeAll / amount; //分割后时间间隔
    21         var slidingTime = 0; //循环开始
    22         var momentTime_front;  
    23         var momentTime_rear;
    24         for(slidingTime; slidingTime < timeAll; slidingTime += timeGap) {
    25             momentTime_front = addDatetime(startTimes, slidingTime)
    26             momentTime_rear = addDatetime(startTimes, (slidingTime + timeGap - 1))
    28             timeRange.push(new range(momentTime_front, momentTime_rear));
    29         }
    30         return timeRange;
    31     }
    32 }
    复制代码

     

    接下来的问题就是如何计算 momentTime_front 和 momentTime_rear 了

    我的思路是将开始时间加上秒数转换后的日时分秒等再相加,直接添加的语句或者方法没找到,那咋办?还把我难住了?找不到算了,技不如人,不如自己写一个方法,直接计算两个字符串类型的时间格式相加,哼╭(╯^╰)╮

    先想想怎么写,需要现将字符串转换成字符串类型的数组,将年月日时分秒都分开才能逐个击破,分开后的数组都是字符串类型,没法进行加减运算,强转!先写个将日期类型转换为整型数组的方法

    复制代码
     1 //传入'1970-01-01 00:00:00' 将其分成可计算的整形数组[1970,1,1,0,0,0]
     2 function getArray(dataTime) {
     3     dataTime = dataTime.replace(/ /, "-")
     4     var timesArray = dataTime.split("-");
     5     var timeArray = timesArray[3].split(":");
     6     timesArray[0] = parseInt(timesArray[0]);
     7     timesArray[1] = parseInt(timesArray[1]);
     8     timesArray[2] = parseInt(timesArray[2]);
     9     timesArray[3] = parseInt(timeArray[0]);
    10     timesArray[4] = parseInt(timeArray[1]);
    11     timesArray[5] = parseInt(timeArray[2]);
    12     return timesArray;
    13 }
    复制代码

     

    ok,能计算了,但是增加的时间是秒,还得把秒转换成年月日时分秒格式

    复制代码
     1 //将秒转换为日期格式(最高到天)
     2 function getDatetime(s) {
     3     var dataTime = new Array;
     4     //存入 秒
     5     dataTime[5] = parseInt((s / 1) % 60);
     6     //存入 分
     7     dataTime[4] = parseInt((s / 60) % 60);
     8     //存入 时
     9     dataTime[3] = parseInt((s / 60 / 60) % 24);
    10     //存入 日
    11     dataTime[2] = parseInt(s / 60 / 60 / 24);
    12     //存入 月
    13     dataTime[1] = parseInt(0);
    14     //存入 年
    15     dataTime[0] = parseInt(0);
    16     return dataTime;
    17 }
    复制代码

     

    好嘞,需要的类有了,可是时间相加,不是简单的数字相加啊,还要考虑闰年问题,大月小月问题,嗯....计算大月小月

    【本文由“java程序”发布,2017年10月14日】

    展开全文
  • SELECT Min(id),Min(date) FROM a GROUP by (UNIX_TIMESTAMP(date) DIV 120)该语句是指将时间分为每2分钟为一个区间,并查询每区间的最小id及date

    SELECT Min(id),Min(date) FROM a GROUP by (UNIX_TIMESTAMP(date) DIV 120)

    该语句是指将时间分为每2分钟为一个区间,并查询每个区间的最小id及date

    展开全文
  • 输入一个天数总为16的日期时间段,判断这个时间段跨了几周,再判断这几周的天数类型,求指教啊 *(1)跨周: * 772,(2全周+一个2),加权平均值算法:(A*7+b*7+c*2)/16; * 376,平均值算法:(A*3+b*7+c...
  • package Test; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.List;...* 根据段时间区间,按月份拆分成多个时间段...

    package Test;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.List;
    import org.junit.Test;
    /**
     * 根据一段时间区间,按月份拆分成多个时间段
     * @author wjl
     *
     * 
     */
    public class SplitDateUtil {
        /*
        * 测试数据
        * "2017/8/2","2017/8/2" √
        * "2017/8/2","2017/8/20" ×
        * "2017/8/2","2018/8/31" √
        * "2017/8/2","2017/8/31" √
        * "2017/8/2","2018/4/20" √
        * "2017/8/22","2018/4/10" √
        */
        @Test
        public void demo(){
            SplitDateUtil.getKeyValueForDate("2017/8/2","2017/8/2");
            System.out.println("-------------------");
            SplitDateUtil.getKeyValueForDate("2017/8/2","2017/8/20");
            System.out.println("-------------------");
            SplitDateUtil.getKeyValueForDate("2017/8/2","2018/8/31");
            System.out.println("-------------------");
            SplitDateUtil.getKeyValueForDate("2017/8/2","2018/4/20");
            System.out.println("-------------------");
            SplitDateUtil.getKeyValueForDate("2017/8/22","2018/4/10");
            System.out.println("-------------------");
            SplitDateUtil.getKeyValueForDate("2017/8/22","2016/4/10");
        }
        /**
        * 根据一段时间区间,按月份拆分成多个时间段
        * @param startDate 开始日期
        * @param endDate  结束日期
        * @return
        */
        public static List<KeyValueForDate> getKeyValueForDate(String startDate,String endDate) {
            List<KeyValueForDate> list = null;
            try {
                list = new ArrayList<KeyValueForDate>();
                // 定义起始日期
                Date d1 = new SimpleDateFormat("yyyy/MM/dd").parse(startDate);
                // 定义结束日期
                Date d2 = new SimpleDateFormat("yyyy/MM/dd").parse(endDate);
                // 获取Calendar
                Calendar calendar = Calendar.getInstance();
                // 设置时间
                calendar.setTime(d1);
                // 设置日期为最大日期
                calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
                Date d3 = new SimpleDateFormat("yyyy/MM/dd").parse(sdf.format(calendar.getTime()));
                //System.out.println(sdf.format(d3));
                Date temp1 = d1;
                Date temp2 = d3;
                //结束日期小于开始日期
                if(d2.before(d1)){
                    System.out.println("请输入正确的结束日期!");
                    return null;
                }
                //结束日期大于开始日期
                while (temp2.before(d2)) {
                    System.out.println(sdf.format(temp1)+"--------"+sdf.format(temp2));
                    //获取下一个月第一天
                    calendar.add(Calendar.MONTH, 1);
                    calendar.set(Calendar.DAY_OF_MONTH,1);
                    temp1 = new SimpleDateFormat("yyyy/MM/dd").parse(sdf.format(calendar.getTime())) ;
                    //获取下一个月份的最后一天
                    calendar.setTime(temp1);
                    calendar.add(Calendar.MONTH, 0);
                    calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
                    temp2 = new SimpleDateFormat("yyyy/MM/dd").parse(sdf.format(calendar.getTime())) ;
                }
                System.out.println(sdf.format(temp1)+"--------"+sdf.format(d2));
            } catch (Exception e) {
                return null;
            }
            return null;
        }
    }

    class KeyValueForDate{

        private String startDate;
        
        private String endDate;
        
        public String getStartDate() {
            return startDate;
        }
        public void setStartDate(String startDate) {
            this.startDate = startDate;
        }
        public String getEndDate() {
            return endDate;
        }
        public void setEndDate(String endDate) {
            this.endDate = endDate;
        }


    }

    展开全文
  • 以5分钟为一分割一天时间

    千次阅读 2015-06-17 14:46:00
    根据题目就能知道需求,就是将一天时间以5分钟一给列出来。 SELECT to_date('2015-06-17','yyyy-mm-dd hh24:mi')+numtodsinterval((ROWNUM-1)*5,'minute') logtime FROM dual CONNECT BY ROWNUM<=TRUNC(...
  • 如何做到,分割并取出>=1h的数据(开始时间,结束时间),加入新集合中! 类似["22:28:27","22:40:28","23:18:15","23:28:27"],[n:nn:nn.....",n:nn:nn.....",n:nn:nn....."] 求大神指导一下!
  •  * 把指定时间段切份 - N份  * -----------------------------------  * @param string $start 开始时间  * @param string $end 结束时间  * @param int $nums 切分数目  * @param boolean 是否格式化 ...
  • * 根据段时间区间,按月份拆分成多个时间段 * @author lxg * * 2016年9月5日下午6:18:36 */ public class SplitDateUtil { @Test public void demo (){ List<KeyValueForDate> list = ...
  • 时间上的处理 有段时间没弄小程序了,现在又来堆点低级问题处理,需求如下,预定类型小程序的一个页面,之前很少...- 下面是固定时间段,选中后增加半小时,取消后恢复 给看客老爷上图 :选择状态的处理 ...
  • SELECT TO_DATE('2013-08-03 10', 'YYYY-MM-DD HH24') + (LEVEL - 1) * 15 / (24 * 60) DATE_JG FROM DUAL CONNECT BY LEVEL (TO_DATE('2013-08-03 1
  • java 计算有效时长,有一时间段不计算时长计算...同一天内有6种情况,分别是 00:00:00[s][e]01:00:00; 00:00:00[s]01:00:00 AND 01:00:00[e]06:00:00 00:00:00[s]01:00:00 AND 06:00:00[e]23:59:59 01:00:00[s][e]06
  • 时间段的比较分为两种: 1:带日期的两具体的时间段比较,如比较2018-01-01 12:00~14:00和2018-01-01 15:00~17:00 2:忽略日期,只比较时分秒,如比较每天的 12:00~14:00 和 18:00和22:00 两种的主要区别是第二...
  • 一个字符串类型的数组将8存入其中,然后循环比较。比较的时候要将字条串用split(“-”)先分割开,再分别转为Date类型。假如d1是起始时间,d2是结束时间,当前时间是d3,d3.after(d1)为true,d3.before(d2)为...
  • 我现在在做一查询,将一天分为4段时间(0:00-6:00、6:00-12:00、12:00-18:00、18:00-24:00),现在随便给定一个时间,比如17:28分,就要把12:00-18:00之间的所有数据都查询出来,小弟初学SQL,望大家多指导,谢谢
  • 这只是部分数据,数据可能一直到9月19号的,如何去根据这时间数据去计算有多少呢? 需要用到python中的pandas库和datetime库 # 把处理过的这列的数据取出来 col=df2.iloc[:,2] #因为col带有index值和...
  • 数据结构实验——就餐人数最多的时间段

    千次阅读 多人点赞 2019-08-01 22:30:09
    就餐时间被分为了 N 个时间段,其中 N 可能会非常大,可以假 设 N 为 1 亿,也就是 100000000(这要求程序不能声明长度为 N 的数组或定义 N 变量), 若未考虑此情况则不能得分。 要求:排序算法的平均时间复杂度...
  • 访问量(读写混合)一个实例不能承受 2)Memcached(缓存)+ MySql + 垂直拆分 通过缓存来缓解数据库的压力,优化数据库的结构和索引 垂直拆分指的是:分成多数据库存储数据(如:卖家库与买家库) 3)MySql主从...
  • 最近在研究报表,要做一实时的统计一天各个时段的数据增量,以2小时为一组统计,发现这sql语句不简单,和大家分享一下我的写法。 做出来的效果如下:   sql语句如下: select count(distinct ro....
  • 写在冬日的第一天--一女程序员第六年工作总结

    万次阅读 热门讨论 2010-11-07 02:54:00
    工作这些年,年年雷打不动一篇总结让初初参加工作的这一天刻在我的脑海中。到现在我已经记不得恋爱纪念日了,却依然知道在冬天到来的第一天敲下过去一年工作的点点滴滴。   似乎在每总结开篇都会说,我...
  • 事物飞速发展之时,往往需要你停下脚步,回顾自己所处的位置,否则你会很容易陷入对细节...人工智能的三个阶段 我们倾向于把人工智能看做新事物,尤其是新技术以及和深度学习相关的新技巧。然而,人工智能已经过数...
  • 向AI转型的程序员都关注了这号????????????大数据挖掘DT机器学习 公众号:datayx本博客分享新人第次参加天池比赛的实况记录,比较完整地给出了数据预处理,缺失值补全,...
  • 用5字段代表5不同的时间单位(中间用空格隔开): 分 时 日 月 星期几 0 2 * * * 表示每天凌晨2点 */10 * * * * 每隔10分钟次 45 10 * * 1-5 每星期的星期到星期五的10:45分执行 · M-N 指定范围值 ·...
  • 最近在使用C#代码连接Oracle数据库,分为两部分,WCF的客户端与服务端。程序启动与运行都没有问题,部署到服务器上后,运行也没有问题。但是第二再访问的时候,就会抛出下边所示的异常。这是怎么回事? Oracle...
  • 我在阿里工作的这段时间里,都学到了哪些东西

    万次阅读 多人点赞 2019-08-18 21:38:28
    段时间没写过原创了,想了各种理由,发现其实理由就一个,没时间。 我来阿里,已经几月了。这段时间,最大的感受就是累。我是在今年的四月份加入阿里的。 当初我没有参加阿里巴巴的实习,而是选择了直接...
  • Python-将音频批量切成段一

    千次阅读 热门讨论 2020-06-09 14:14:15
    由于工作需要将音频批量切成段一的,没找到啥工具,所以写了这脚本。 1.代码如下: from pydub import AudioSegment from pydub.utils import make_chunks audio = AudioSegment.from_file("电视剧...
  • 在所有的物流仓储系统中,关于计费时间点,可以分为2种情况,种是按时间点计费,种是按周期收费。按时间点计费一般是只要业务发生则发生了计费。例如:装卸费、车辆入闸费、安装费、分拣费、包装费、配送费等等...
  • 鉴于每环节都可以做为一个专题来进行探讨,所以受篇幅和时间限制,本文对有关问题未做深入剖析,只做一个宏观上的介绍。一般而言,软件测试从项目确立时就开始了,前后要经过以下一些主要环节: 需求分析→测试...
  • 与微博不同,微信从不以用户数量论英雄,因此我们并不知道“小道消息”的微信账号到底有多少追随者,但可以猜测或许是8万左右,因为这数目是国博微信公众 号在2013年5月16日一天增加的用户数量,在这一天,国博...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 135,765
精华内容 54,306
关键字:

一天分为3个时间段