java各种时间处理

import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 日期工具类
 */
public class TimeFormat {
    private static Log log = LogFactory.getLog(TimeFormat.class);

    private static final TimeFormat INSTANCE = new TimeFormat();
    
    /** 一天的毫秒数 */
    public final static long MILLISECONDDAY = 1000*24*60*60;
    /** 一天的秒数 */
    public final static long SECONDDAY = 24*60*60;
    /** 一个小时的毫秒数 */
    public final static long MILLISECONDHOUR = 1000*60*60;
    /** 一个小时的秒数 */
    public final static long SECONDHOUR = 60*60;
    /** 一分钟的毫秒数 */
    public final static long MILLISECONDMINUTE = 1000*60;
    /** 一分钟的秒数 */
    public final static long SECONDMINUTE = 60;

    /** 以当前日期推算一天 */
    public final static int DAY = 1;
    /** 以当前日期推算一周 */
    public final static int WEEK = 2;
    /** 以当前日期推算一月 */
    public final static int MONTH = 3;
    /** 以当前日期推算一季 */
    public final static int SEASON = 4;
    /** 以当前日期推算一年 */
    public final static int YEAR = 5;
    
    private TimeFormat() {
    }

    public static TimeFormat getInstance() {
        return INSTANCE;
    }

    /**
     * 根据指定的格式显示时间
     *
     * @param time
     *            long
     * @param format
     *            String
     * @return String
     */
    public String getSpecifiedDate(long time, String format) {
        if (time == 0) {
            return "-";
        }

        Date timeVal = new Date(time);

        String strTime = null;
        try {
            SimpleDateFormat simpledateformat = new SimpleDateFormat(format);
            strTime = simpledateformat.format(timeVal);
        } catch (Exception ex) {
            log.error("Format " + format + " error : " + ex);
            strTime="-";
        }
        return strTime;
    }
    
    /**
     * 获取与指定日期相隔的日期，数据统计是按照日历的类型：
     * type的取值为：DAY、WEEK、MONTH、SEASON、YEAR；
     * count是对应type的统计数，比如一个月、五个月等。
     * count>0,从当前日期向后推算；
     * count<0,从当前日期向前推算。
     * @param format1        返回的日期类型
     * @param format2        输入的日期类型
     * @param nowDate        当前日期
     * @param type            计算日期类型：日、周、月、季、年
     * @param count            统计日期类型的数
     */
    public String getCalDate(String format1, String format2,String nowDate, int type, int count) {
        String resultDate = "";
        
        try {
            SimpleDateFormat resultFormat = new SimpleDateFormat(format1);
            SimpleDateFormat dateFormat = new SimpleDateFormat(format2);
            Calendar cal = Calendar.getInstance();
            cal.setTime(dateFormat.parse(nowDate));
            switch(type) {
                case DAY :
                    cal.add(Calendar.DATE, count);
                    break;
                case WEEK :
                    cal.add(Calendar.DATE, 7 * count);
                    break;
                case MONTH :
                    cal.add(Calendar.MONTH, count);
                    break;
                case SEASON :
                    cal.add(Calendar.MONTH, 3 * count);
                    break;
                case YEAR :
                    cal.add(Calendar.YEAR, count);
                    break;
                default :
                    cal.add(Calendar.DATE, 0);
                    break;
            }
            resultDate = resultFormat.format(cal.getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
        return resultDate;
    }

    /**
     * 计算两个日期之间相差的时间，可以计算的时间间隔有：日、周、月、季、年
     * @param format            传入日期的格式
     * @param startTime            开始时间
     * @param endTime            结束时间
     * @param type                获取时间间隔类型
     * @return                    返回时间间隔类型中相差的时间
     */
    public int getCalDateDiff(String format,String startTime, String endTime, int type) {
        int days = 0;
        
        try {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
            long diff = simpleDateFormat.parse(endTime).getTime() - simpleDateFormat.parse(startTime).getTime();        //获得两个时间的毫秒时间差异
            switch(type) {
                case DAY :
                    days = (int) (diff / MILLISECONDDAY);
                    break;
                case WEEK :
                    days = (int) (diff / MILLISECONDDAY / 7);
                    break;
                case MONTH :
                    days = (int) (diff / MILLISECONDDAY / 30);
                    break;
                case SEASON :
                    days = (int) (diff / MILLISECONDDAY / 90);
                    break;
                case YEAR :
                    days = (int) (diff / MILLISECONDDAY / 365);
                    break;
                default :
                    days = (int) (diff / MILLISECONDDAY);
                    break;
            }
            
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
        return days;
    }

    /**
     * 格式 ： 输出指定格式类型的时间
     *
     * @param formater
     *            String
     * @return String
     */
    public String getNowDate(String formater) {
        String strTime = null;
        try {
            SimpleDateFormat simpledateformat = new SimpleDateFormat(formater);
            strTime = simpledateformat.format(new Date());
        } catch (Exception ex) {
            log.error("Format " + formater + " error : " + ex);
        }
        return strTime;
    }

    /**
     * 将timeType转换后的浮点型的值
     */
    public long getTimeToLong(String time,String format) {
        Date date = null;
        String timeShowFormat = format;
        try {
            SimpleDateFormat formatter = new SimpleDateFormat(timeShowFormat);
            ParsePosition pos = new ParsePosition(0);
            date = formatter.parse(time, pos);
        } catch (Exception ex) {
            System.err.println("Format " + timeShowFormat + " error : " + ex);
        }
        return date.getTime();
    }
    
    /**
     * 将日期进行格式化，如将2007-09-08改为：2007年9月8日
     */
    public String formatDateString(String time,String format) {
        Date date = null;
        String timeShowFormat = format;
        try {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
            date=formatter.parse(time);
            
        } catch (Exception ex) {
            return "-";
        }
        return getSpecifiedDate(date.getTime(), format);
        
    }
    /**
     * 将日期进行格式化，如将2007-09-08改为：2007年9月8日
     */
    public String formatDate(String time,String format) {
        Date date = null;
        String timeShowFormat = format;
        try {
            SimpleDateFormat formatter = new SimpleDateFormat(timeShowFormat);
            date=formatter.parse(time);
            
        } catch (Exception ex) {
            return "-";
        }
        return getSpecifiedDate(date.getTime(), format);
        
    }

    /**
     * 取得当前的时间
     *
     * @return long
     */
    public long getCurrentTime() {
        GregorianCalendar gc = new GregorianCalendar();
        Date datenow = gc.getTime();
        return datenow.getTime();
    }
    
    /**
     * 取得星期
     * @param str
     * @return
     */
    public static String getWeek(String date,String format){
        String week="";
        Date mydate=new Date();
        SimpleDateFormat myFormatter = new SimpleDateFormat(format);
        try{
        mydate= myFormatter.parse(date);
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
        SimpleDateFormat formatter4 = new SimpleDateFormat("E");
        week=formatter4.format(mydate);
        return week;
    }
    
    /**
     * 取得星期
     * @param str
     * @return
     */
    public static String getTodayWeek(){
        String week="";
        Date mydate=new Date();
        SimpleDateFormat formatter4 = new SimpleDateFormat("E");
        week=formatter4.format(mydate);
        return week;
    }
    
    /**
     * 获取日期字符串 如
     * @return
     */
    public String getCurrentDateString() {
        StringBuffer info = new StringBuffer();
        String[] weekDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日");
        Calendar cal = Calendar.getInstance();
        String end = sf.format(cal.getTime());
        info.append(end+" ");
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0) {
            w = 0;
        }
        info.append(weekDays[w]);

        return info.toString();
    }
    
    /**
     * 间隔n天的秒数
     * @return
     */
    public static int[] getIntevalTime(){
        int[] lo = new int[2];
        int ll = (int)(System.currentTimeMillis() / 1000);
        lo[1]=ll;
        ll = ll - 24*60*60*1000 / 1000;
        lo[0] =ll;
        return lo;
    }
    
    //以下是王喜新写的相关日期处理方法
    
    /** 获取指定日期格式的当前时间 */
    public String getNowTime(String format) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        String date = dateFormat.format(new Date());
        return date;
    }
    
    /**
     * 将时间戳转换为指定日期格式的时间，时间戳为秒
     *
     * @param format    日期格式
     * @param time        以秒计算的时间戳
     */
    public String getSecondTime(String format, long time){
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        String str = dateFormat.format(new Date(time*1000));
        return str;
    }
    
    /**
     * 将时间戳转换为指定日期格式的时间，时间戳为毫秒
     *
     * @param format    日期格式
     * @param time        以毫秒计算的时间戳
     */
    public String getMilliSecondTime(String format, long time){
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        String str = dateFormat.format(new Date(time));
        return str;
    }
    
    /**
     * 将指定格式的时间转换为时间戳，得到的时间戳是秒计算
     *
     * @param format        输入的日期格式
     * @param time            日期字符串
     */
    public long getTimeToSecond(String format, String time){
        long timeLong = 0;
        SimpleDateFormat simpleDateFormat =new SimpleDateFormat(format);
        try {
            Date date = simpleDateFormat .parse(time);
            timeLong = date.getTime() / 1000;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return timeLong;
    }
    
    /**
     * 将指定格式的时间转换为时间戳，得到的时间戳是毫秒计算
     *
     * @param format        输入的日期格式
     * @param time            日期字符串    
     */
    public long getTimeToMilliSecond(String format, String time){
        long timeLong = 0;
        SimpleDateFormat simpleDateFormat =new SimpleDateFormat(format);
        try {
            Date date = simpleDateFormat .parse(time);
            timeLong = date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return timeLong;
    }
    
    /**
     * 转换日期的格式，将日期格式从一种形式转换为另外一种形式
     *
     * @param format1        转换后的日期格式
     * @param format2        转换前的日期格式
     * @param dateString    转换前的日期字符串
     */
    public String getTimesChange(String format1,String format2, String dateString){
        long timeLong = 0;
        SimpleDateFormat simpleDateFormat =new SimpleDateFormat(format2);
        try {
            Date date = simpleDateFormat .parse(dateString);
            timeLong = date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        String str = "";
        SimpleDateFormat dateFormat = new SimpleDateFormat(format1);
        str = dateFormat.format(new Date(timeLong));
        return str;
    }
    
    /**
     * 计算两个日期之间相差的天数
     *
     * @param format        日期的格式
     * @param startTime        开始日期
     * @param endTime        结束日期
     */
    public long getDateDiff(String format, String startTime, String endTime) {
        SimpleDateFormat simpledatedate = new SimpleDateFormat(format);
        
        long diff;
        long day = 0;
        
        try {
            diff = simpledatedate.parse(endTime).getTime() - simpledatedate.parse(startTime).getTime();        //获得两个时间的毫秒时间差异
            day = diff/MILLISECONDDAY;        //计算差多少天
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return day;
    }
    
    /**
     * 获取与指定日期相隔几天的日期，
     * 如果days<0，那么计算的是当前日期之前的某个日期
     * 如果days>0，那么计算的是当前日期之后的某个日期
     *
     * @param format1        返回日期的日期格式
     * @param format2        当前指定日期的日期格式
     * @param nowDate        指定的日期
     * @param daybefore        相差的天数
     * @return
     */
    public String getDate(String format1, String format2, String nowDate, int days){
        String resultDate = "";
        
        SimpleDateFormat resultFormat = new SimpleDateFormat(format1);
        SimpleDateFormat dateFormat = new SimpleDateFormat(format2);
        
        try {
            long diff = dateFormat.parse(nowDate).getTime() + days * MILLISECONDDAY;
            resultDate = resultFormat.format(new Date(diff));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return resultDate;
    }
    
    /**
     * 获取一定形式的日期数据
     *
     * @param calendarType    日期的形式
     * @param format        传入的日期格式
     * @param date            日期字符串
     * @return
     */
    public int getDate(int calendarType, String format, String date) {
        int day = 0;
        
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        try {
            long diff = dateFormat.parse(date).getTime();
            Date dateTime = new Date(diff);
            Calendar cal = Calendar.getInstance();
            cal.setTime(dateTime);
            day = cal.get(calendarType);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return day;
    }
    
    /**
     * 比较两个指定格式的日期大小：
     * 如果arg1>arg2，那么结果返回true；如果arg1<arg2，那么结果返回false
     *
     * @param format    指定日期的格式
     * @param arg1        要比较的第一个时间
     * @param arg2        要比较的第二个时间
     */
    public boolean getTimeCompare(String format, String arg1, String arg2) {
        boolean result = true;
        
        SimpleDateFormat simpleDateFormat =new SimpleDateFormat(format);
        
        try {
            Date date1 = simpleDateFormat .parse(arg1);
            Date date2 = simpleDateFormat.parse(arg2);
            if(date1.getTime() >= date2.getTime()) {
                result = true;
            } else {
                result = false;
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
        return result;
    }
    
    /**
     * yyyy-MM-dd
     * @param date
     * @return
     */
    public static String formatDateTime1(Date date){
        SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(date);
    }
    /**
     * 把字符日期形式转换为Date格式
     *
     * @param time
     * @return 转化过的Date格式日期
     */
    public static Date getDateTime(String time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date sdfTime = null;
        try {
            sdfTime = sdf.parse(time);
        } catch (ParseException e) {
            log.debug(e.getMessage());
        }
        return sdfTime;
    }
    
    /**
     * yyyy年MM月
     * @param date
     * @return
     */
    public static String formatDateYearMonth(String date, String fmt){
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date fmtDate;
        try {
            if(!"".equals(date)){
                fmtDate = sdf.parse(date);
                SimpleDateFormat sdf1= new SimpleDateFormat(fmt);
                return sdf1.format(fmtDate);
            } else {
                return "";
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static String addYearTime(String date, int count){
        
        if(!"".equals(date)){
            TimeFormat t = new TimeFormat();
            Date fmtDate = t.getDateTime(date);
            Calendar calendar=Calendar.getInstance();
            calendar.setTime(fmtDate);
            calendar.set(Calendar.YEAR,calendar.get(Calendar.YEAR)+count);//让日期加1  
            String dd = t.formatDateTime1(calendar.getTime());
            String ff = t.getTimesChange("yyyy.MM.dd", "yyyy-MM-dd", dd);
            return ff;
        } else {
            return "";
        }
    }
    
    /**
     * 两个日期与当前日期进行比较
     * @param dateStart
     * @param dateEnd
     * @return
     */
    public static boolean towTimecompareNow(String dateStart, String dateEnd){
        boolean result =false;
        Date now = new Date();
        SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date1 = simpleDateFormat.parse(dateStart);
            Date date2 = simpleDateFormat.parse(dateEnd);
            String dateStr = simpleDateFormat.format(now);
            Date date3 = simpleDateFormat.parse(dateStr);
            if(date1.getTime() <= date3.getTime() && date2.getTime() >= date3.getTime()) {
                result = true;
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return result;
    }
    
    /**
     * 和当前日期进行比较
     * @param date
     * @return
     */
    public static boolean timecompareNow(String date){
        boolean result =false;
        Date now = new Date();
        SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date1 = simpleDateFormat.parse(date);
            String dateStr = simpleDateFormat.format(now);
            Date date3 = simpleDateFormat.parse(dateStr);
            if(date1.getTime()>=date3.getTime()) {
                result = true;
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return result;
    }
    
    public static String addMonthTime(int count){
        Calendar calendar=Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.MONTH,calendar.get(Calendar.MONTH)-1);//让日期加1  
        Date ff = calendar.getTime();
        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dd = fmt.format(ff);
        return dd;
    }
    
    
    /**
     * yyyy-MM-dd
     * @param date
     * @return
     */
    public static String formatDateTime2(String date){
        SimpleDateFormat sdf= new SimpleDateFormat("yyyyMMdd");
        SimpleDateFormat sdf1= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = "";
        try {
            Date fmtDate = sdf.parse(date);
            str = sdf1.format(fmtDate);
            return str;
        } catch (ParseException e) {
        }
        return str;
    }
    
    
    /**
     * yyyy-MM-dd
     * @param date
     * @return
     */
    public static String formatDateTime3(String date){
        SimpleDateFormat sdf= new SimpleDateFormat("yyyyMMdd");
        SimpleDateFormat sdf1= new SimpleDateFormat("yyyy.MM.dd");
        String str = "";
        try {
            Date fmtDate = sdf.parse(date);
            str = sdf1.format(fmtDate);
            return str;
        } catch (ParseException e) {
        }
        return str;
    }
    
    /**
     * 得到认证结束时间
     * @param CreditIndex    认证编号
     * @param fomat    时间格式类型
     * @return
     */
    public static String getCreditInfoEndTime(String CreditIndex){
        String endStr = "";
        if(!"".equals(CreditIndex)&&CreditIndex.length()>10){
            String time = CreditIndex.substring(2, 10);
            String fmtTime = formatDateTime2(time);
            endStr = addYearTime(fmtTime, 1);
        }
        return endStr;
    }
    
    /**
     * 得到认证结束时间
     * @param CreditIndex    认证编号
     * @param fomat    时间格式类型
     * @return
     */
    public static String getCreditInfoStartTime(String CreditIndex){
        String fmtTime = "";
        if(!"".equals(CreditIndex)&&CreditIndex.length()>10){
            String time = CreditIndex.substring(2, 10);
            fmtTime = formatDateTime3(time);
        }
        return fmtTime;
    }
}