精华内容
下载资源
问答
  • 一年: <select id="getTotalTrend" resultType="java.util.HashMap"> select nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'01',vd_count,0)),0) nums1,...

    近一年:

         <select id="getTotalTrend" resultType="java.util.HashMap">
              select nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'01',vd_count,0)),0) nums1,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'02',vd_count,0)),0) nums2,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'03',vd_count,0)),0) nums3,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'04',vd_count,0)),0) nums4,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'05',vd_count,0)),0) nums5,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'06',vd_count,0)),0) nums6,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'07',vd_count,0)),0) nums7,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'08',vd_count,0)),0) nums8,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'09',vd_count,0)),0) nums9,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'10',vd_count,0)),0) nums10,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'11',vd_count,0)),0) nums11,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'12',vd_count,0)),0) nums12
            
            from vd_basisdata_etl  where  to_char(to_date(op_date,'yyyy-MM-dd'), 'yyyy') = #{year,jdbcType=VARCHAR}
          </select>

    去年:

        SimpleDateFormat format = new SimpleDateFormat("yyyy");
        Calendar c = Calendar.getInstance();
    		c.setTime(new Date());
            c.add(Calendar.YEAR, -1);
            Date y = c.getTime();
            String year = format.format(y);
            map.put("year", year);
          <select id="getTotalTrendLastyear" resultType="java.util.HashMap">
            select nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'01',vd_count,0)),0) nums1,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'02',vd_count,0)),0) nums2,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'03',vd_count,0)),0) nums3,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'04',vd_count,0)),0) nums4,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'05',vd_count,0)),0) nums5,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'06',vd_count,0)),0) nums6,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'07',vd_count,0)),0) nums7,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'08',vd_count,0)),0) nums8,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'09',vd_count,0)),0) nums9,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'10',vd_count,0)),0) nums10,
            nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'11',vd_count,0)),0) nums11,nvl(sum(decode(to_char(to_date(op_date,'yyyy-mm-dd'),'mm'),'12',vd_count,0)),0) nums12
            
            from vd_basisdata_etl  where  to_char(to_date(op_date,'yyyy-MM-dd'), 'yyyy') = #{year,jdbcType=VARCHAR}
          </select>

    近三年:

    <!--上报分年 -->
            <select id="getPatientNumByYear" resultType="java.util.HashMap">
              select 
         nvl(sum(decode(to_char(REPORT_TIME,'yyyy'),to_char(add_months(sysdate, -24), 'yyyy'),1,0)),0) nums1,
         nvl(sum(decode(to_char(REPORT_TIME,'yyyy'),to_char(add_months(sysdate, -12), 'yyyy'),1,0)),0) nums2,
         nvl(sum(decode(to_char(REPORT_TIME,'yyyy'),to_char(add_months(sysdate, 0), 'yyyy'),1,0)),0) nums3
          
            from STROKE
            where 1=1   
        </select>

    近几个季度:

        <!--上报分季度 -->
            <select id="getPatientNumBySeason" resultType="java.util.HashMap">
             select nvl(sum(decode(to_char(REPORT_TIME,'mm'),'01',1,'02',1,'03',1,0)),0) nums1,
               nvl(sum(decode(to_char(REPORT_TIME,'mm'),'04',1,'05',1,'06',1,0)),0) nums2,
                nvl(sum(decode(to_char(REPORT_TIME,'mm'),'07',1,'08',1,'09',1,0)),0) nums3,
                nvl(sum(decode(to_char(REPORT_TIME,'mm'),'10',1,'11',1,'12',1,0)),0) nums4
            from STROKE
            where 1=1 
          </select>

    近几天:

        <!--上报分天 -->
            <select id="getPatientNumByDay" resultType="java.util.HashMap">
         select
              COALESCE(b.zs,0) as zs,
    	a.today
    	from ((SELECT 
        to_char (SYSDATE- LEVEL + 1, 'mm/dd') today
        FROM
        DUAL connect BY LEVEL &lt;= 5) a 
        left join (
        select count(0) as zs ,  to_char (o.REPORT_TIME, 'mm/dd') REPORT_TIME from STROKE  o GROUP BY to_char (o.REPORT_TIME, 'mm/dd'))b
        on a.today=b.REPORT_TIME) order by a.today
    </select>

     

    展开全文
  • 入海一年零两个月总结

    千次阅读 2020-09-16 20:44:55
    今天的总结很奇怪, 不是月末不是季度末不是年末, 可能就是突然想总结工作这一年零2个月6天的感受吧. 或者是对所有过往的总结 那我也从 身体健康、财务理财、人际社群、家庭生活、工作事业、学习成长、体验突破、休闲...

    2020916总结[碎碎念][万万没想到, 一直没更新, 竟然还涨粉了]

    今天看了若川的博客, 受到启发, 与其写很多计划, 不如直接做一些总结, 以此自勉
    今天的总结很奇怪, 不是月末不是季度末不是年末, 可能就是突然想总结工作这一年零2个月6天的感受吧. 或者是对所有过往的总结

    那我也从 身体健康、财务理财、人际社群、家庭生活、工作事业、学习成长、体验突破、休闲放松这八个方面进行总结好了.

    • 身体健康

    大学的时候一个人经常去操场跑步, 研究生的时候两个人, 偶尔去操场跑步, 偶尔去游泳, 偶尔去练瑜伽. 如今工作了, 没去跑过步, 没练瑜伽, 游过一次泳. 最近受好朋友激励, 下班后会在家自己运动一下, 希望能坚持下去.
    大学的时候12点睡, 研究生的时候12:30睡, 现在工作了却要1:00睡. 哎, 可能知道白天自己的时间少, 所以拼命想在夜晚多给自己一点放松的时间吧, 根本没什么事, 但就是不想睡. 仗着自己是10:00上班嚣张呗, 但不得不说, 上班时间还是会经常犯困, 如果换下一份工作我希望上班时间能早点, 这样我就会逼着自己早点睡了.
    上学的时候三餐规律, 按时吃饭, 如今午饭12点, 晚饭不定. 由于公司7点下班, 我一般8点左右走, 有时候回家吃, 吃上饭有时候就9:00多了. 前段时间肠胃经常出bug, 于是现在胆小的我经常6:30下楼吃晚饭. 下班的时候经常会想, 如果这个时候回家能吃到一顿香喷喷的饭, 那应该是世上最幸福的一件事了吧 . (现在8:36了, 我又没吃晚饭, 哭唧唧)

    • 财务理财

    工作一年多, 可以买自己喜欢的衣服, 用贵的护肤品, 去想去的地方, 前几天还送了自己一个macbook, 自己赚的钱, 为什么不呢…… 前提是在自己有余力的条件下才可以, 月光不存在的 , 现在也攒了几万块了. 但是不会理财, 害怕. 所以存款就一直在银行里躺着了

    • 人际社群

    工作后几乎没怎么交到新朋友, 这是应了那句同事就是同事吗?
    当前以前的老朋友也有走着走着就散了的, 但是我相信只要回来那个熟悉的地方, 没什么是一顿烧烤解决不了的. 有几个其他城市的最好的朋友, 经常聊天, 分享生活; 有几个一起来上海的研究生朋友, 经常 小聚, 也是给单调的生活增添了一些调味料吧 .

    • 家庭生活

    从小地方考出来的孩子不容易. 这是我最近经常感叹的一句话.
    大学办助学贷款, 日子过的还好 . 研究生的时候不想办了, 结果很是拮据, 现在想来, 这几千块对现在的自己来说很easy, 当年为什么不提前消费呢, 哈哈
    不过话说回来, 虽然不富裕, 爸妈也没让我吃苦受累. 当年高考报考老师建议报考软件工程(后两年学费每年14000), 爸妈也丝毫没犹豫, 还供我继续读研深造. 如今工作一年, 终于有能力靠自己改善爸妈的生活了. 给家里出钱装修, 弟弟考大学送了一部华为手机, 节日生日等还会给他们送他们平时舍不得买的礼物, 这些都是我最最值得骄傲的事啊 .我肯定也是他们的骄傲呢. 还有一个非常爱你的男朋友, 两个人一起在大上海打拼, 这么想想也是很幸运的.

    • 工作事业

    怎么说呢, 现在的公司什么都好, 就是有点太闲了…囧
    人都说, 入职前两年是进步最大, 打基础的两年 , 现在一年过去了, 问自己技术有多少成长呢? 不敢说, 毕竟最近又是没有工作的日子, 每天自己学习, 效率也较低.
    不过按照自己的计划, 一步步去做吧, 靠自己怕什么, 你从小不就是靠自己的吗?!

    • 学习成长

    把所有学的东西都整理到印象笔记里, 画一些思维导图便于理解真是一个好习惯. 技术书也会看, 代码整洁之道 , 深入理解ES6, JS高级程序设计, 重学前端, 等等.
    也经常刷掘金, 跟着大神们学习, 我以后也要多写博客, CSDN一年没更新了, 要继续拾起来啊!
    对了, 最近在刷LeetCode了, 会坚持下去的

    • 体验突破

    不知道这个体验突破指的是什么, 解锁新技能做饭算不算. 上班之后学会了做饭, 工作日偶尔会给自己做一顿便当, 周末经常自己做. 要学习剪辑视频, 希望年底总结的时候能加上这一项

    • 休闲放松

    前几天总结了一下这些年去过的城市, 竟然发现国内大多数旅游城市都去过了. 作为一个大学之前没出过县城的人来说, 真是一件不容易的事情.
    今年疫情, 6月底在男票的强烈要求下, 去了一趟三亚, 晒个半死, 但是心情还是愉悦的. 端午时请了三天年假, 去了三亚, 加上往返一共6天, 每天晃晃悠悠的玩, 不紧不慢, 住着💰120左右的海景房, 喝着水果捞, 属实惬意
    刚从三亚回来那几天我一直在想, 旅行的意义究竟是什么呢? 是为了见没见过的世界吗? 海边还不都是差不多的. 是为了短暂的逃离一成不变的生活吗? 嗯, 有点小道理, 但不至于完全是. 那是为了什么呢? 这几个月我想明白了, 那短暂的旅行是平凡生活的添加剂呀, 那一点甜也不是几天的甜, 而是能够一直在记忆里支撑你的甜. 工作间隙偶尔回忆起来, 莞尔一笑, 足矣. 可能这才是旅行的意义吧.

    说完了, 2020年还有三个月, 希望你能不负时光, 勇往直前吧.

    展开全文
  • // 添加第一 既开始时间 lDate.add(sdf.format(calBegin.getTime())); while (calBegin.compareTo(calEnd)) { // 根据日历的规则,为给定的日历字段添加或减去指定的时间量 calBegin.add(Calendar.DAY_OF_...
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class ReportDateUtils {
    
        /**
         * (日)计算去年同期和上期的起止时间   (日)
         * beginkey、endkey  返回的map key
         *
         * begin \  end本期起止日期
         */
        public static Map<String,String> getDayDate(int type,String beginkey,String endkey,String begin,String end){
            Map<String,String> map = new HashMap<String, String>();
             DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                if (type == 1) {// 计算上期
                    // 计算查询时间段相隔多少天
                    long beginTime = date1.getTime();
                    long endTime = dEnd.getTime();
                    long inter = endTime - beginTime;
                    if (inter < 0) {
                        inter = inter * (-1);
                    }
                    long dateMillSec = 24 * 60 * 60 * 1000;
                    long dateCnt =  inter / dateMillSec;
                    long remainder = inter % dateMillSec;
                    if (remainder != 0) {
                        dateCnt++;
                    }
                    int day = Integer.parseInt(String.valueOf(dateCnt))+1;
                    calBegin.add(Calendar.DATE, -day);// 像前推day天
                    calEnd.add(Calendar.DATE, -day);// 像前推day天
                }else if(type==2){
                    calBegin.add(Calendar.YEAR, -1);// 去年同期
                    calEnd.add(Calendar.YEAR, -1);// 去年同期
                }
                map.put(beginkey, sdf.format(calBegin.getTime()));
                map.put(endkey, sdf.format(calEnd.getTime()));
              } catch (ParseException e) {
                  e.printStackTrace();
              }
            return map;
            
        }
        
        /**
         * (日)返回时间段内的所有的天  type 0本期    1上期   2去年同期(日)
         * @param begin  起始日期
         * @param end    截止日期
         * @return
         */
        public static List<String> getDaysList(String begin,String end){
             DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
             List<String> lDate = new ArrayList<String>();
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                // 添加第一个 既开始时间
                lDate.add(sdf.format(calBegin.getTime()));
                while (calBegin.compareTo(calEnd)<0) {
                    // 根据日历的规则,为给定的日历字段添加或减去指定的时间量
                    calBegin.add(Calendar.DAY_OF_MONTH, 1);
                    Date ss = calBegin.getTime();
                    String str = sdf.format(ss);
                    lDate.add(str);
                }
              } catch (ParseException e) {
                  e.printStackTrace();
              }
             return lDate;
        }
    
        /**
         * (周)计算(周) 上期和去年同期的起止日期和起止周
         * 计算上期的起止时间 和去年同期  type 0本期    1上期   2去年同期
         * 起始日期key  beginkey  endkey
         * 起始日期的起止周key  beginWkey  endWkey
         * 本期:begin    end
         * 本期起止周 beginW、endW
         */
        public static Map<String,String> getWeekDate(int type,String beginkey,String endkey,String beginWkey,String endWkey,String begin,String end,String beginW,String endW){
            Map<String,String> map = new HashMap<String, String>();
             DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                calBegin.setFirstDayOfWeek(Calendar.MONDAY);
                calEnd.setFirstDayOfWeek(Calendar.MONDAY);
                if (type == 1) {// 计算上期
                    // 计算查询时间段相隔多少周
                    int week = getWeekCount(date1,dEnd);
                    //往前推week周
                    calBegin.add(Calendar.WEEK_OF_YEAR, -week);// 像前推week周
                    calEnd.add(Calendar.WEEK_OF_YEAR, -week);// 像前推week周
                    map.put(beginWkey, String.valueOf(calBegin.get(Calendar.WEEK_OF_YEAR)));//得到其实日期的周);
                    map.put(endWkey, String.valueOf(calEnd.get(Calendar.WEEK_OF_YEAR)));//得到其实日期的周);
                    //得到起始周的周一   和结束周的周末
                    int day_of_week = calBegin.get(Calendar.DAY_OF_WEEK) - 1;
                    if (day_of_week == 0)
                        day_of_week = 7;
                    calBegin.add(Calendar.DATE, -day_of_week + 1);
                    //本周周末
                    int day_of_week_end = calEnd.get(Calendar.DAY_OF_WEEK) - 1;
                    if (day_of_week_end == 0)
                        day_of_week_end = 7;
                    calEnd.add(Calendar.DATE, -day_of_week_end + 7);
                }else if(type==2){
                    calBegin.add(Calendar.YEAR, -1);// 去年同期
                    calEnd.add(Calendar.YEAR, -1);// 去年同期
                    
                    //去年的开始的本周
                    calBegin.set(Calendar.WEEK_OF_YEAR,Integer.parseInt(beginW));
                    calEnd.set(Calendar.WEEK_OF_YEAR,Integer.parseInt(endW));
                    //年-1   周不变
                    map.put(beginWkey,beginW);
                    map.put(endWkey,endW);
                    
                    //得到起始周的周一   和结束周的周末
                    int day_of_week = calBegin.get(Calendar.DAY_OF_WEEK) - 1;
                    if (day_of_week == 0)
                        day_of_week = 7;
                    calBegin.add(Calendar.DATE, -day_of_week + 1);
                    //本周周末
                    int day_of_week_end = calEnd.get(Calendar.DAY_OF_WEEK) - 1;
                    if (day_of_week_end == 0)
                        day_of_week_end = 7;
                    calEnd.add(Calendar.DATE, -day_of_week_end + 7);
                }
                map.put(beginkey, sdf.format(calBegin.getTime()));
                map.put(endkey, sdf.format(calEnd.getTime()));
              } catch (ParseException e) {
                  e.printStackTrace();
              }
            return map;
            
        }
        
        
        
        /**
         * (周)返回起止时间内的所有自然周
         * @param begin  时间起
         * @param end   时间止
         * @param startw  周起
         * @param endW    周止
         * @return
         */
        public static List<String> getWeeksList(String begin,String end,String startw,String endW){
             DateFormat sdf = new SimpleDateFormat("yyyy");
             List<String> lDate = new ArrayList<String>();
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                //开始时间是今年的第几周
                calBegin.setFirstDayOfWeek(Calendar.MONDAY);
                int count = calBegin.get(Calendar.WEEK_OF_YEAR);//得到其实日期的周
                //添加第一个周
                int beginww = Integer.parseInt(startw);
                int endww = Integer.parseInt(endW);
                
                int beginY = calBegin.get(Calendar.YEAR);
                int endY = calEnd.get(Calendar.YEAR);
                
                int weekall = getAllWeeks(beginY+"");
                //如果是同一年
                do{
                    lDate.add(beginY+"年第"+beginww+"周");
                    if(beginww==weekall){
                        beginww = 0;
                        beginY++;
                        weekall = getAllWeeks(beginY+"");
                    }
                    if(beginY==endY &&beginww==endww){
                        break;
                    }
                    beginww++;
                }while(beginY<=endY);
              } catch (ParseException e) {
                  e.printStackTrace();
              }
             return lDate;
        }
        
        /**
         * (月)得当时间段内的所有月份
         * @param StartDate
         * @param endDate
         * @return
         */
        public static List<String> getYearMouthBy(String StartDate,String endDate) {
              DateFormat df = new SimpleDateFormat("yyyy-MM");
              Date date1 = null; // 开始日期
              Date date2 = null; // 结束日期
              try {
                   date1 = df.parse(StartDate);
                   date2 = df.parse(endDate);
              } catch (ParseException e) {
                  e.printStackTrace();
              }
              Calendar c1 = Calendar.getInstance();
              Calendar c2 = Calendar.getInstance();
              //定义集合存放月份
              List<String> list = new ArrayList<String>();
              //添加第一个月,即开始时间
              list.add(df.format(date1));
              c1.setTime(date1);
              c2.setTime(date2);
              while (c1.compareTo(c2) < 0) {
                   c1.add(Calendar.MONTH, 1);// 开始日期加一个月直到等于结束日期为止
                   Date ss = c1.getTime();
                   String str = df.format(ss);
                   list.add(str);
              }
              return list;
        }
        
        /**
         * (月)计算本期的上期和去年同期   1 上期   2同期  
         * 返回的mapkay  beginkey   endkey
         * 本期起止:begin    end
         * 计算上期的起止时间 和去年同期  type 0本期    1上期   2去年同期
         */
        public static Map<String,String> getMonthDate(int type,String beginkey,String endkey,String begin,String end){
            Map<String,String> map = new HashMap<String, String>();
             DateFormat sdf = new SimpleDateFormat("yyyy-MM");
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                if (type == 1) {// 计算上期
                    int year = calBegin.get(Calendar.YEAR);
                    int month = calBegin.get(Calendar.MONTH);
                    
                    int year1 = calEnd.get(Calendar.YEAR);
                    int month1 = calEnd.get(Calendar.MONTH);
                    int result;
                    if(year==year1){
                      result=month1-month;//两个日期相差几个月,即月份差
                    }
                    else{
                      result=12*(year1-year)+month1-month;//两个日期相差几个月,即月份差
                    }
                    result++;
                    calBegin.add(Calendar.MONTH, -result);// 像前推day天
                    calEnd.add(Calendar.MONTH, -result);// 像前推day天
                }else if(type==2){
                    calBegin.add(Calendar.YEAR, -1);// 去年同期
                    calEnd.add(Calendar.YEAR, -1);// 去年同期
                }
                map.put(beginkey, sdf.format(calBegin.getTime()));
                map.put(endkey, sdf.format(calEnd.getTime()));
              } catch (ParseException e) {
                  e.printStackTrace();
              }
            return map;
            
        }
    
        /**
         * (年)计算本期(年)的上期
         */
        public static Map<String,String> getYearDate(String beginkey,String endkey,String begin,String end){
            Map<String,String> map = new HashMap<String, String>();
             DateFormat sdf = new SimpleDateFormat("yyyy");
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                int year = calBegin.get(Calendar.YEAR);
                int year1 = calEnd.get(Calendar.YEAR);
                int result;
                result = year1 - year + 1;// 两个日期的年份差
                calBegin.add(Calendar.YEAR, -result);// 像前推N年
                calEnd.add(Calendar.YEAR, -result);// 像前推N年
                map.put(beginkey, sdf.format(calBegin.getTime()));
                map.put(endkey, sdf.format(calEnd.getTime()));
              } catch (ParseException e) {
                  e.printStackTrace();
              }
            return map;
            
        }
        
        /**
         * 获取年份时间段内的所有年
         * @param StartDate
         * @param endDate
         * @return
         */
        public static List<String> getYearBy(String StartDate,String endDate) {
              DateFormat df = new SimpleDateFormat("yyyy");
              Date date1 = null; // 开始日期
              Date date2 = null; // 结束日期
              try {
                   date1 = df.parse(StartDate);
                   date2 = df.parse(endDate);
              } catch (ParseException e) {
                  e.printStackTrace();
              }
              Calendar c1 = Calendar.getInstance();
              Calendar c2 = Calendar.getInstance();
              //定义集合存放月份
              List<String> list = new ArrayList<String>();
              //添加第一个月,即开始时间
              list.add(df.format(date1));
              c1.setTime(date1);
              c2.setTime(date2);
              while (c1.compareTo(c2) < 0) {
                   c1.add(Calendar.YEAR, 1);// 开始日期加一个月直到等于结束日期为止
                   Date ss = c1.getTime();
                   String str = df.format(ss);
                   list.add(str);
              }
              return list;
        }
    
        /**
         * 获取两个日期段相差的周数
         */
        public static int getWeekCount(Date date1,Date dEnd){
            Calendar c_begin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            c_begin.setTime(date1);
            Calendar c_end = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            c_end.setTime(dEnd);
            int count = 0;
    //        c_end.add(Calendar.DAY_OF_YEAR, 1); // 结束日期下滚一天是为了包含最后一天
            c_begin.setFirstDayOfWeek(Calendar.MONDAY);
            c_end.setFirstDayOfWeek(Calendar.MONDAY);
            while (c_begin.before(c_end)) {
                if (c_begin.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
                    count++;
                }
                c_begin.add(Calendar.DAY_OF_YEAR, 1);
            }
            return count;
        }
        
        /**
         * 返回该年有多少个自然周
         * @param year   最多53  一般52
         * 如果12月月末今天在本年53周(属于第二年第一周) 那么按照当年52周算
         * @return
         */
        public static int getAllWeeks(String year){
              Calendar calendar = Calendar.getInstance();
              SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
               try {
                calendar.setTime(sdf.parse(year+"-12-31"));
            } catch (ParseException e) {
                e.printStackTrace();
            }
              calendar.setFirstDayOfWeek(Calendar.MONDAY);
              int count = calendar.get(Calendar.WEEK_OF_YEAR);//得到其实日期的周
              int week =  calendar.get(Calendar.WEEK_OF_YEAR);
              if(week != 53){
                 week = 52;
              }
              return week;
        }
        
        /**
         *
         * (季度) 计算本期的上期起止时间和同期的起止时间
         * 返回的mao key 时间起止:beginkey   endkey   季度起止: beginWkey  endWkey
         * 本期的时间起止:begin end   季度:beginW  endW
         * type 0本期    1上期   2去年同期  季度
         */
        public static Map<String,String> getQuarterDate(int type,String beginkey,String endkey,String beginWkey,String endWkey,String begin,String end,String beginW,String endW){
            //计算本期的起始日期 和截止日期
            Map<String,String> map = new HashMap<String, String>();
             DateFormat sdf = new SimpleDateFormat("yyyy");
              Date date1 = null; // 开始日期
              Date dEnd = null; // 结束日期
              try {
                date1 = sdf.parse(begin);
                dEnd = sdf.parse(end);
                Calendar calBegin = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calBegin.setTime(date1);
                calBegin.set(Calendar.MONTH, setMonthByQuarter(Integer.parseInt(beginW)));
                Calendar calEnd = Calendar.getInstance();
                // 使用给定的 Date 设置此 Calendar 的时间
                calEnd.setTime(dEnd);
                calEnd.set(Calendar.MONTH, setMonthByQuarter(Integer.parseInt(endW)));
                
                if (type == 1) {// 计算上期
                    // 计算查询时间段相隔多少季度(多少个月)
                    int quarter =  ((Integer.parseInt(end)-Integer.parseInt(begin))*4+(Integer.parseInt(endW) - Integer.parseInt(beginW))+1)*3;
                    //往前推week周
                    calBegin.add(Calendar.MONTH, -quarter);// 像前推week月份
                    calEnd.add(Calendar.MONTH, -quarter);// 像前推week月份   
                    map.put(beginWkey,String.valueOf(getQuarterByMonth(calBegin.get(Calendar.MONTH))));//得到其实日期的月);
                    map.put(endWkey,String.valueOf(getQuarterByMonth(calEnd.get(Calendar.MONTH))));//得到其实日期的月);
                }else if(type==2){
                    calBegin.add(Calendar.YEAR, -1);// 去年同期
                    calEnd.add(Calendar.YEAR, -1);// 去年同期
                    //年-1   周不变
                    map.put(beginWkey,beginW);
                    map.put(endWkey,endW);
                }
                map.put(beginkey,String.valueOf(calBegin.get((Calendar.YEAR)))+"-"+setMonthByQuarterToString(0,Integer.parseInt(map.get(beginWkey))));
                map.put(endkey, String.valueOf(calEnd.get((Calendar.YEAR))+"-"+setMonthByQuarterToString(1,Integer.parseInt(map.get(endWkey)))));
              } catch (ParseException e) {
                  e.printStackTrace();
              }
            return map;
            
        }
        /**
         * (季度)获取季度份时间段内的所有季度
         * @param StartDate
         * @param endDate
         * @return
         */
        public static List<String> getQuarterBy(String StartDate,String beginQ,String endDate,String endQ) {
            DateFormat sdf = new SimpleDateFormat("yyyy-MM");
            Date date1 = null; // 开始日期
            Date dEnd = null; // 结束日期
    
            try {
                date1 = sdf.parse(StartDate);
                dEnd = sdf.parse(endDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
    
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            List<String> list = new ArrayList<String>();
            int beginY = calBegin.get(Calendar.YEAR);
            int beginYQ = Integer.parseInt(beginQ);
            int endY = calEnd.get(Calendar.YEAR);
            int endYQ = Integer.parseInt(endQ);
            do {
                list.add(beginY + "年第" + beginYQ + "季度");
                if (beginY == endY && beginYQ == endYQ) {
                    return list;
                }
                beginYQ++;
                if (beginYQ > 4) {
                    beginYQ = 1;
                    beginY++;
                }
             }while(true);
        }
        
        
        //根据季度给年设置月份
        /**
         * 根据季度返回季度第一月
         */
        public static int setMonthByQuarter(int quarter){
            if(quarter==1){
                return 1;
            }
            if(quarter==2){
                return 4;
            }
            if(quarter==3){
                return 7;
            }
            if(quarter==4){
                return 10;
            }
            
            return 1;
            
        }
    
        
        /**
         * 根据季度返回季度第一月或最后一月
         * 0 起始月  1截止月
         *
         */
        public static String setMonthByQuarterToString(int type,int quarter){
            if(quarter==1){
                if(type==1){
                    return "03";
                }
                return "01";
            }
            if(quarter==2){
                if(type==1){
                    return "06";
                }
                return "04";
            }
            if(quarter==3){
                if(type==1){
                    return "09";
                }
                return "07";
            }
            if(quarter==4){
                if(type==1){
                    return "12";
                }
                return "10";
            }
            return "01";
            
        }
        /**
         * 根据月份获取所在季度
         * @param month
         * @return
         */
        private static int getQuarterByMonth(int month){
            int quarter = 1;
            if(month>=1&&month<=3){
                return 1;
            }
            if(month>=4&&month<=6){
                return 2;
            }
            if(month>=7&&month<=9){
                return 3;
            }
            if(month>=10&&month<=12){
                return 4;
            }
            
            return quarter;
            
        }
        
        public static void main(String[] args) throws Exception{
              String start = "2012-02-28";
              String end = "2012-03-01";
    //          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    //          List<String> lDate = getDaysList(start, end);
    //          for (String date : lDate)
    //          {
    //             System.out.println(date);
    //          }
    //          System.out.println(getWeeksList("2014-03-30","2014-04-14"));-- aa=2014-03-02, bb=2014-03-17
    //          System.out.println(getWeekDate(2,"aa","bb","cc","dd","2014-03-30","2014-04-14","13","16"));
    //          System.out.println(getWeeksList("2014-03-30","2014-04-14","13","16"));
    //          System.out.println(getAllWeeks("2013"));
    //          System.out.println(getQuarterDate(1,"aaa","bbb","ccc","ddd","2014","2014","2","2"));
    //          System.out.println(getYearBy("2013","4","2014","2"));
              
         }
        
    
    }
    
    


    展开全文
  • 获取当前月份所属季度之前的四个季度(可以获取多个),比如说是:当前是2017年9,就属于2017年的第三季度用2017Q3表示。我想要获取2017Q2、2017Q1、2016Q4、...
  • } /** * 根据获得季度 * @param month  * @return 季度 */ private static int getQuarter(int month) { if(month == 1 || month == 2 || month == 3){ return 1; }else if(month == 4 || month == 5 || ...

     

        /**
         *根据时间范围获得月份集
         * @return
         */
        public static List<String> getRangeSet(String beginDate,String endDate){
            /*      Date1.after(Date2),当Date1大于Date2时,返回TRUE,当小于等于时,返回false;
              Date1.before(Date2),当Date1小于Date2时,返回TRUE,当大于等于时,返回false;
              如果业务数据存在相等的时候,而且相等时也需要做相应的业务判断或处理时,你需要使用:!Date1.after(Date2);*/
            List<String> rangeSet =null;
            SimpleDateFormat sdf = null;
              Date begin_date = null;
              Date end_date = null;
              rangeSet = new java.util.ArrayList<String>();
              sdf = new SimpleDateFormat("yyyy-MM");
            try {
                  begin_date = sdf.parse(beginDate);//定义起始日期
                  end_date = sdf.parse(endDate);//定义结束日期
            } catch (ParseException e) {
                System.out.println("时间转化异常,请检查你的时间格式是否为yyyy-MM或yyyy-MM-dd");
            }
              Calendar dd = Calendar.getInstance();//定义日期实例
              dd.setTime(begin_date);//设置日期起始时间
              while(!dd.getTime().after(end_date)){//判断是否到结束日期
                  rangeSet.add(sdf.format(dd.getTime()));
                  dd.add(Calendar.MONTH, 1);//进行当前日期月份加1
              }
              return rangeSet;
        }   

     

     

     

        /**
         *根据时间范围获得季度集
         * @return
         */
        public static List<String> getRangeSet_Q(String beginDate,String endDate){
            /*      Date1.after(Date2),当Date1大于Date2时,返回TRUE,当小于等于时,返回false;
              Date1.before(Date2),当Date1小于Date2时,返回TRUE,当大于等于时,返回false;
              如果业务数据存在相等的时候,而且相等时也需要做相应的业务判断或处理时,你需要使用:!Date1.after(Date2);*/
            List<String> rangeSet =null;
            SimpleDateFormat sdf = null;
              Date begin_date = null;
              Date end_date = null;
              String[] numStr =null;
              String Q=null;
              rangeSet = new java.util.ArrayList<String>();
              sdf = new SimpleDateFormat("yyyy-MM");
            try {
                  begin_date = sdf.parse(beginDate);//定义起始日期
                  end_date = sdf.parse(endDate);//定义结束日期
            } catch (ParseException e) {
                System.out.println("时间转化异常,请检查你的时间格式是否为yyyy-MM或yyyy-MM-dd");
            }
              Calendar dd = Calendar.getInstance();//定义日期实例
              dd.setTime(begin_date);//设置日期起始时间
              while(!dd.getTime().after(end_date)){//判断是否到结束日期
                  numStr=  sdf.format(dd.getTime()).split("-",0);
                  Q = getQuarter(Integer.valueOf(numStr[1]))+"";
                  System.out.println(numStr[0].toString()+"年"+numStr[1].toString()+"月"+"为"+numStr[0].toString()+"年第"+Q+"季");
                  rangeSet.add(Q);
                  dd.add(Calendar.MONTH, 1);//进行当前日期月份加1
              }
              return rangeSet;
        }   

     

     

     

        /**
         * 根据月获得季度
         * @param month  月
         * @return  季度
         */
        private static int getQuarter(int month) {
            if(month == 1 || month == 2 || month == 3){
                return 1;
            }else if(month == 4 || month == 5 || month == 6){
                return  2;
            }else if(month == 7 || month == 8 || month == 9){
                return 3;
            }else{
                return 4;
            }
        }

    展开全文
  •  那么1231号中午12点之后和121号的12点之前是不包含在这范围之内的。   所以,当时间需要精确的时候,觉得to_char还是必要的    7. 日期格式冲突问题   输入的格式要看你安装的ORACLE字符集的...
  • pandas里面方法可以求出一日期在一年中属于第周(w列),但是如何求在某个季度是第周呢?例如下表,方法可以直接求出最后一列,但是如何求第一列呢?
  • //由于DayOfWeek返回的是数字的星期,我们要把它转换成汉字方便我们阅读,有些人可能会用switch来一地对照,其实不用那么麻烦的  string[] Day = new string[] { "星期日", "星期一", "星期二", ...
  • 转自:... 取一年中的12月份 效率差的方法: select to_char(add_months(to_date('201106','yyyymm'),-rownum+1),'yymm') from tb_dmcs_daq where rownum union all sel
  • 1.计算第周 selectdatepart(wk,'2020-12-31') 第周 2.计算星期 select case datepart(dw,getdate()) when 1 then '星期天 ' when 2 then '星期一 ' when 3 then '星期二 ' when 4 then '星期三 '...
  • * 项目:Java编程实现获取本周在当前年的第周、当前的第周、当前季度的第几季度 * 时间:2019/8/14 * 作者:郑翰林 */ import java.util.Calendar; public class Date6 { public static void main(String[]...
  • 查询每一年个月的数据个数和 select  sum(case month(updateTime) when '1' then 1 else 0 end) as 一月份, sum(case month(updateTime) when '2' then 1 else 0 end) as 二月份, sum(case month(updateTime...
  • 个月的全部日期 SELECT to_char(TRUNC(to_date(to_char(sysdate,'yyyy-mm')||'-01','yyyy-MM-dd'), 'MM') + ROWNUM - 1, 'yyyy-MM-dd') as day FROM dual connect by to_char(last_day(to_date(to_char(sysdate,'...
  • //返回这一年个月的天数 public static int tianShu(int nian, int yue) { if (yue == 2) { if (shiFouRunNian(nian)) { return 29; } else { return 28; } } int ts = 0; switch (yue) { case 1: ...
  • 使用Calendar的add(int field, int amount)方法 ...//得到一Calendar的实例 ca.setTime(new Date()); //设置时间为当前时间 ca.add(Calendar.YEAR, -1); //年份减1 Date lastMonth = ca.getTime(); /...
  • Shell 获取指定日期的前N个季度的起止日期
  • tableau-计算一个月内的第

    千次阅读 2020-11-13 09:34:46
    1.先要得到每个月的第一天,使用fixed,取本月第一天,此处的限定为本月真伪我使用的是时间参数自动把数据限定在本月 2.开始计算本年内的周数和本月第一天在本年内的周数,如果是相等,则就是本月第一周,如果...
  • 一年有12个月,分为四个季度,怎样判断当前月份是第几个季度呢 方法一、if else 判断 1.flutter: ///当前月份 int _currentMonth = DateTime.now().month; ///季度 int quarter; if (_currentMonth >= ...
  • 1.一年中的某一天是哪一天 select to_char(sysdate,'yyyy-MM-dd') from dual; ...3.一年中的某一天是哪一 select to_char(sysdate,'mm') from dual; 4.一年中的某一天是哪一季度 select t...
  • 个月来说不出的感受,重于摸到了“学习”的感觉了,一切都步入正轨; 2017新的这半年我要好好努力,这半年会决定我 今后的人生走向, 这半年我要打好计算机学习的专业基础和基本学科的知识素养; 知识,技能,...
  • 这是计算一个月第一天的SQL 脚本:   SELECT DATEADD(mm, DATEDIFF(mm,0,getdate()), 0) --当月的第一天 SELECT DATEADD(mm, DATEDIFF(mm,0,getdate())-1, 0) --上个月的第一天 SELECT DATEADD(ms,-3,...
  • //当这一年的11日为周日时则本年54周,否则没有54周,没有则去除第54周的提示 var _week = date.getDay(); if(_week!=0){//一年53周情况 if(weeks==54){ return '今年没有54周'; } var cnt=0;// ...
  • # java获取一年的周数、单周开始时间与结束时间、一年所有周开始时间与结束时间、开始时间与结束时间 package com.frgk.produce.util; import org.springframework.util.CollectionUtils; import java.text....
  • $time = "2020-11-20 00:00:00"; $res = (new Carbon)->setTimeFromTimeString($time)->addMonths(-10)->toDateTimeString(); 转载于:https://www.cnblogs.com/Skril...
  •  //得到上一个月的最后一天的毫秒值   var lastMonthLastDayMSec = nowMonthFirstDay.getTime() - 1 * dayMSec;   var lastMonthLastDay = new Date(lastMonthLastDayMSec);     return lastMonthFirstDay....
  • //月份需要更新为0 也就是下一年的第一个月 if(currentMonth==11){ currentYear++; currentMonth=0;//就为 }else{ //否则只是月份增加,以便求的下一月的第一天 currentMonth++; } //一天的毫秒...
  • 获取某年某多少周、多少天、第一周是号 获取今天是今年的第周、第天 总结 好久没有记录工作中遇到的问题,其中的原因之一应该是没有什么代表性的或者说是没有网上搜不到答案的,毕竟在大多数...
  • 这是计算一个月第一天的SQL 脚本:  SELECT DATEADD(mm, DATEDIFF(mm,0,getdate()), 0) --当月的第一天 SELECT DATEADD(mm, DATEDIFF(mm,0,getdate())-1, 0) --上个月的第
  • MySQL 时间获取计算周、、季度 获取当前时间在这一年是第几周(国外计算方式,周日为一周的第一天) ...获取现在是今年的第几个季度 获取当前季度的第一天日期 获取当前季度的最后一天日期 获取指定季度的起止日期
  • Matlab时间序列分析

    万次阅读 多人点赞 2018-11-13 18:53:46
    在引入时间序列前,先介绍几个matlab函数 matlab中的gallery函数简析 Matlab 中的 gallery 函数是一个测试矩阵生成函数。当我们需要对某些算法进行测试的时候,可以利用gallery函数来生成各种性质的测试矩阵。其用法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,957
精华内容 8,782
关键字:

一年有几个月几个季度