java 时间各种转换处理

最新推荐文章于 2023-07-14 17:30:30 发布
最新推荐文章于 2023-07-14 17:30:30 发布
阅读量503 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014473525/article/details/71420055
版权 
package com.roshi.utils.common;

import java.lang.reflect.Constructor;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;

public final class DateUtils {

    public static final DateFormat YM = new SimpleDateFormat("yyyyMM");
    public static final DateFormat YMD = new SimpleDateFormat("yyyyMMdd");
    public static final DateFormat YMD_DASH = new SimpleDateFormat("yyyy-MM-dd");
    public static final DateFormat YMD_DOT = new SimpleDateFormat("yyyy.MM.dd");
    public static final DateFormat YMD_DASH_HM = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    public static final DateFormat FULL_TIME = new SimpleDateFormat("yyyyMMddHHmmss");
    public static final DateFormat FULL_TIME_DASH = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static final DateFormat FULL_TIME_SLASH = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    public static final DateFormat TIMESTAMP = new SimpleDateFormat("yyyyMMddHHmmssSSS");
    public static final DateFormat TIMESTAMP_DASH = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    public static final String[] INTERVAL_CN = {
        "年","个月","周","周","天","天","天","天","上午/下午","小时","小时","分","秒","毫秒"
    };
    private static final long[] MILLS = new long[]{
        TimeUnit.DAYS.toMillis(1),
        TimeUnit.DAYS.toMillis(1),
        TimeUnit.DAYS.toMillis(1),
        TimeUnit.DAYS.toMillis(1),
        TimeUnit.HOURS.toMillis(12),
        TimeUnit.HOURS.toMillis(1),
        TimeUnit.HOURS.toMillis(1),
        TimeUnit.MINUTES.toMillis(1),
        TimeUnit.SECONDS.toMillis(1), 1};

    /*
     * 工具类，私有类构造方法，禁止使用new生成对象
     */
    private DateUtils() {}

    /**
     * 获得系统日期(无时分秒)
     * 
     * @return
     */
    public static Date getSystemDate() {

        return truncation(Calendar.getInstance().getTime());
    }

    /**
     * 获得系统时间
     * 
     * @return
     */
    public static Date getSystemTime() {

        return Calendar.getInstance().getTime();
    }

    /**
     * 获得系统时间
     * 
     * @return
     */
    public static <T extends Date> T getSystemTime(Class<T> clz) {

        Constructor<T> con;
        try {
            con = clz.getConstructor(long.class);

            return con.newInstance(getSystemTime().getTime());
        } catch (Exception e) {
            return null;
        }

    }

    /**
     * 获得系统日期无格式的字符串(无时分秒)
     * 
     * @return
     */
    public static String getSystemDateNoFormat() {

        return formatDateNone(getSystemDate());
    }

    /**
     * 获得系统日期中国显示格式的字符串(无时分秒)
     * 
     * @return
     */
    public static String getSystemDateDash() {

        return formatDateDash(getSystemDate());
    }

    /**
     * 获得系统日期(yyyy.MM.dd)的字符串(无时分秒)
     * 
     * @return
     */
    public static String getSystemDateDot() {

        return formatDateDot(getSystemDate());
    }

    /**
     * 获得系统日期(yyyy-MM-dd HH:mm)的字符串(带小时和分钟)
     * 
     * @return
     */
    public static String getSystemDateDashWithHM() {

        return formatDateDashWithHM(getSystemDate());
    }

    /**
     * 获得系统时间戳中国显示格式的字符串
     * 
     * @return
     */
    public static String getSystemFullTimeDash() {

        return formatFullTimeDash(getSystemTime());
    }

    /**
     * 获得系统时间无格式的字符串
     * 
     * @return
     */
    public static String getSystemFullTimeNoFormat() {

        return formatFullTimeNone(getSystemTime());
    }

    /**
     * 获得系统时间戳无格式的字符串
     * 
     * @return
     */
    public static String getSystemTimestampNoFormat() {

        return formatTimestampNone(getSystemTime());
    }

    /**
     * 获得系统时间戳中国显示格式的字符串
     * 
     * @return
     */
    public static String getSystemTimestampDash() {

        return formatTimestampDash(getSystemTime());
    }

    /**
     * 将日期对象格式化为无分隔字符串(yyyyMMdd,如:20140103)
     * 
     * @param d
     * @return
     */
    public static String formatDateNone(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return YMD.format(d);
    }

    /**
     * 将日期对象格式化为中国显示格式的字符串(yyyy-MM-dd,如:2014-01-03)
     * 
     * @param d
     * @return
     */
    public static String formatDateDash(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return YMD_DASH.format(d);
    }

    /**
     * 将日期对象格式化为字符串(yyyy.MM.dd,如:2014.01.03)
     * 
     * @param d
     * @return
     */
    public static String formatDateDot(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return YMD_DOT.format(d);
    }

    /**
     * 将日期对象格式化为字符串(yyyy-MM-dd HH:mm,如:2014.01.03)
     * 
     * @param d
     * @return
     */
    public static String formatDateDashWithHM(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return YMD_DASH_HM.format(d);
    }

    /**
     * 将完整的时间对象格式化为无分隔字符串
     *   (yyyyMMddHHmmss,如:20140103132450为 2014年1月3日 13点24分50秒)
     * 
     * @param d
     * @return
     */
    public static String formatFullTimeNone(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return FULL_TIME.format(d);
    }

    /**
     * 将完整的时间对象格式化为中国显示格式的字符串
     *   (yyyy-MM-dd HH:mm:ss,如:2014-01-03 20:14:30为 2014年1月3日 20点14分30秒)
     * 
     * @param d
     * @return
     */
    public static String formatFullTimeDash(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return FULL_TIME_DASH.format(d);
    }

    /**
     * 将完整的时间对象格式化为字符串
     *   (yyyy/MM/dd HH:mm:ss,如:2014/01/03 20:14:30为 2014年1月3日 20点14分30秒)
     * 
     * @param d
     * @return
     */
    public static String formatFullTimeSlash(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return FULL_TIME_SLASH.format(d);
    }

    /**
     * 将时间戳对象格式化为无分隔字符串
     *   (yyyyMMddHHmmssSSS,如:20140103132450834为 2014年1月3日 13点24分50秒834毫秒)
     * 
     * @param d
     * @return
     */
    public static String formatTimestampNone(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return TIMESTAMP.format(d);
    }

    /**
     * 将时间戳对象格式化为中国显示格式的字符串
     *   (yyyy-MM-dd HH:mm:ss.SSS,如:2014-01-03 20:14:30.223为 2014年1月3日 20点14分30秒223毫秒)
     * 
     * @param d
     * @return
     */
    public static String formatTimestampDash(Date d) {
        if (d == null) return StringUtils.EMPTY;

        return TIMESTAMP_DASH.format(d);
    }

    /**
     * 将时间戳对象自定义的格式
     * 
     * @param d
     * @param pattern 自定义格式字符串
     * @return
     */
    public static String formatCustomize(Date d, String pattern) {
        if (d == null) return StringUtils.EMPTY;

        if (StringUtils.isEmpty(pattern)) {
            return TIMESTAMP_DASH.format(d);
        }

        return new SimpleDateFormat(pattern).format(d);
    }

    /**
     * 格式化现在时间到输入时间的差值
     * 
     * @param day 指定日期
     * @return
     */
    public static String formatIntervalFrowNow(Date day, int scale, String prefix, String suffix) {
        if (day == null) return StringUtils.EMPTY;

        Calendar current = Calendar.getInstance();
        Calendar end = Calendar.getInstance();
        end.setTime(day);
        if (!current.before(end)) return StringUtils.EMPTY;

        StringBuilder sb = new StringBuilder();
        if (prefix != null) sb.append(prefix).append(' ');
        if (suffix == null) suffix = StringUtils.EMPTY;

        int tf, df = scale >>> 4;
        if (df == 0) {
            df = scale;
            tf = scale;
        } else {
            tf = scale & 15;
        }

        int d = end.get(Calendar.HOUR_OF_DAY) < current.get(Calendar.HOUR_OF_DAY) ? -1 : 0;
        d += end.get(Calendar.DATE) - current.get(Calendar.DATE);
        int m = d < 0 ? -1 : 0;
        int y = end.get(Calendar.YEAR) - current.get(Calendar.YEAR);
        m += end.get(Calendar.MONTH) - current.get(Calendar.MONTH);
        if (m < 0) { y--; m+=12; }
        if (d < 0) { d+=current.getMaximum(Calendar.DAY_OF_MONTH); }
        if (df == Calendar.DAY_OF_YEAR) {
            d = (int) ((end.getTimeInMillis() - current.getTimeInMillis()) / MILLS[0]);
            if (d > 0) sb.append(d).append(INTERVAL_CN[Calendar.DAY_OF_YEAR - 1]);
        } else if (df < Calendar.AM_PM) {
            if (y > 0) sb.append(y).append(INTERVAL_CN[Calendar.YEAR - 1]);
            if (df == Calendar.YEAR) return sb.append(suffix).toString();

            if (m > 0) sb.append(m).append(INTERVAL_CN[Calendar.MONTH - 1]);
            if (df == Calendar.MONTH) return sb.append(suffix).toString();

            if (df == Calendar.DATE) {
                if (d > 0) sb.append(d).append(INTERVAL_CN[Calendar.DAY_OF_MONTH - 1]);
            } else {
                int w = d / 7;
                if (w > 0) sb.append(w).append(INTERVAL_CN[Calendar.WEEK_OF_MONTH - 1]);
                if (df < Calendar.DATE) return sb.append(suffix).toString();
                w = d % 7;
                if (d > 0) sb.append(w).append(INTERVAL_CN[Calendar.DAY_OF_WEEK - 1]);
            }
        } else {
            if (y > 0) sb.append(y).append(INTERVAL_CN[Calendar.YEAR - 1]);
            if (m > 0) sb.append(m).append(INTERVAL_CN[Calendar.MONTH - 1]);
            if (d > 0) sb.append(d).append(INTERVAL_CN[Calendar.DAY_OF_MONTH - 1]);
        }

        if (tf > 10) {
            long mills = (end.getTimeInMillis() - current.getTimeInMillis()) % MILLS[0], val;
            int max = tf - 4;
            boolean hasBefore = false;
            for (int i = Calendar.HOUR_OF_DAY - Calendar.DATE; i < max; i++) {
                val = mills / MILLS[i];
                if (hasBefore || val > 0) {
                    hasBefore = true;
                    sb.append(val).append(INTERVAL_CN[i + 4]);
                }
                mills = mills % MILLS[i];
            }
        }
        return sb.append(suffix).toString();
    }

    /**
     * 将输入的年月字符串转换为日期 {@link Date}类型
     *   默认字符串日期格式为(yyyyMM)
     * 
     * @param date
     * @return
     */
    public static Date getYearMonth(String ym) {

        if (StringUtils.isEmpty(ym)) {
            Calendar c = Calendar.getInstance();
            c.set(Calendar.DAY_OF_MONTH, 1);
            return c.getTime();
        }

        try {
            return YM.parse(ym);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为日期 {@link Date}类型
     *   默认字符串日期格式为(yyyyMMdd)
     * 
     * @param date
     * @return
     */
    public static Date getDate(String date) {

        if (StringUtils.isEmpty(date)) return getSystemDate();

        try {
            return YMD.parse(date);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为日期 {@link Date}类型
     *   默认字符串日期格式为(yyyy-MM-dd)
     * 
     * @param date
     * @return
     */
    public static Date getDateDash(String date) {

        if (StringUtils.isEmpty(date)) return getSystemDate();

        try {
            return YMD_DASH.parse(date);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为日期 {@link Date}类型
     *   默认字符串日期格式为(yyyy.MM.dd)
     * 
     * @param date
     * @return
     */
    public static Date getDateDot(String date) {

        if (StringUtils.isEmpty(date)) return getSystemDate();

        try {
            return YMD_DOT.parse(date);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为时间 {@link Date}类型
     *   默认字符串日期格式为(yyyy-MM-dd HH:mm:ss)
     * 
     * @param date
     * @return
     */
    public static Date getDateFullDash(String date) {

        if (StringUtils.isEmpty(date)) return getSystemTime();

        try {
            return FULL_TIME_DASH.parse(date);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为时间 {@link Date}类型
     *   默认字符串日期格式为(yyyy/MM/dd HH:mm:ss)
     * 
     * @param date
     * @return
     */
    public static Date getDateFullSlash(String date) {

        if (StringUtils.isEmpty(date)) return getSystemTime();

        try {
            return FULL_TIME_SLASH.parse(date);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为时间 {@link Date}类型
     *   默认字符串日期格式为(yyyy-MM-dd HH:mm:ss)
     * 
     * @param date
     * @return
     */
    public static <T extends Date> T getDateFullDash(String date, Class<T> clz) {

        if (StringUtils.isEmpty(date)) return null;

        try {
            Constructor<T> con = clz.getConstructor(long.class);

            return con.newInstance(FULL_TIME_DASH.parse(date).getTime());
        } catch (Exception e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为时间戳 {@link Date}类型
     *   默认字符串日期格式为(yyyy-MM-dd HH:mm:ss.SSS)
     * 
     * @param date
     * @return
     */
    public static Timestamp getDateTimestampDash(String date) {

        if (StringUtils.isEmpty(date)) return getSystemTime(Timestamp.class);

        try {
            return new Timestamp(TIMESTAMP_DASH.parse(date).getTime());
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 将输入的字符串转换为日期 {@link Date}类型
     * 
     * @param date
     * @param format
     * @return
     */
    public static Date getDate(String date, String format) {

        if (StringUtils.isEmpty(date)) return getSystemDate();

        try {
            return new SimpleDateFormat(format).parse(date);
        } catch (ParseException e) {
            // 日期格式错误时返回空对象
            return null;
        }
    }

    /**
     * 获得输入天的结束时间
     * 
     * @param day 指定日期
     * @return
     */
    public static long calcDayEndInterval(Date day, TimeUnit unit) {
        long start, time;
        if (day == null) {
            start = System.currentTimeMillis();
            time = truncation(start, Calendar.DATE);
        } else {
            start = day.getTime();
            time = truncation(day.getTime(), Calendar.DATE);
        }

        if (unit == TimeUnit.MILLISECONDS) {
            return time + MILLS[0] - 1 - start;
        } else {
            return unit.convert(time + MILLS[0] - 1 - start, TimeUnit.MILLISECONDS);
        }
    }

    /**
     * 获得输入天的结束时间
     * 
     * @param day 指定日期
     * @return
     */
    public static long getDayEndMillis(Date day) {
        long time;
        if (day == null) {
            time = truncation(System.currentTimeMillis(), Calendar.DATE);
        } else {
            time = truncation(day.getTime(), Calendar.DATE);
        }

        return time + MILLS[0] - 1;
    }

    /**
     * 获得输入天的结束时间
     * 
     * @param day 指定日期
     * @return
     */
    public static Date getDayEndTime(Date day) {

        long time;
        if (day == null) {
            time = truncation(System.currentTimeMillis(), Calendar.DATE);
        } else {
            time = truncation(day.getTime(), Calendar.DATE);
        }
        time = time + MILLS[0] - 1000;

        return new Date(time);
    }

    /**
     * 获得输入天的结束时间
     * 
     * @param day 指定日期
     * @return
     */
    public static long getEndMillis(Date day, int scale, int add) {

        long time;
        if (day == null) {
            time = truncation(System.currentTimeMillis(), scale);
        } else {
            time = truncation(day.getTime(), scale);
        }

        long level = 0;
        if (Calendar.MILLISECOND <= scale) {
            return time;
        } else if (Calendar.DATE <= scale) {
            level = MILLS[scale - Calendar.DATE];
        }  else {
            Calendar c = Calendar.getInstance();
            c.setTimeInMillis(time);
            c.add(scale, add + 1);
            c.add(Calendar.SECOND, -1);
            return c.getTimeInMillis();
        }
        return time + (add + 1) * level - 1l;
    }

    /**
     * 获得输入天的结束时间
     * 
     * @param day 指定日期
     * @return
     */
    public static Date getEndTime(Date day, int scale, int add) {

        long time;
        if (day == null) {
            time = truncation(System.currentTimeMillis(), scale);
        } else {
            time = truncation(day.getTime(), scale);
        }

        long level = 0;
        if (Calendar.MILLISECOND < scale) {
            // 当前指定格式不支持
            return new Date(time);
        } else if (Calendar.DATE <= scale) {
            level = MILLS[scale - Calendar.DATE];
        } else {
            Calendar c = Calendar.getInstance();
            c.setTimeInMillis(time);
            c.add(scale, add + 1);
            c.add(Calendar.SECOND, -1);
            return c.getTime();
        }
        time = time + (add + 1) * level - 1000l;

        return new Date(time);
    }

    /**
     * 清空日期对象的时分秒
     * 
     * @param d 日期对象
     * @return
     */
    public static Date truncation(Date d) {

        return truncation(d, Calendar.DATE);
    }

    /**
     * 清空日期对象的指定时间域之后的时间
     * 
     * @param d
     * @param scale
     * @return
     */
    public static Date truncation(Date d, int scale) {

        if (d == null) return null;

        return new Date(truncation(d.getTime(), scale));
    }

    private static long truncation(long time, int scale) {

        long level = 0;
        int offset = 0;
        if (Calendar.DATE <= scale) {
            level = MILLS[scale - Calendar.DATE];
        } else if (scale == Calendar.WEEK_OF_YEAR || scale == Calendar.WEEK_OF_MONTH) {
            Calendar c = Calendar.getInstance();
            c.setTimeInMillis(time);
            if (c.get(Calendar.DAY_OF_WEEK) < 2) {
                c.add(scale, -1);
            }
            c.set(Calendar.DAY_OF_WEEK, 2);
            time = c.getTimeInMillis();
            level = MILLS[0];
        } else if (scale == Calendar.MONTH) {
            Calendar c = Calendar.getInstance();
            c.setTimeInMillis(time);
            c.set(Calendar.DAY_OF_MONTH, 1);
            time = c.getTimeInMillis();
            level = MILLS[0];
        } else if (scale == Calendar.YEAR) {
            Calendar c = Calendar.getInstance();
            c.setTimeInMillis(time);
            c.set(Calendar.MONTH, 0);
            c.set(Calendar.DAY_OF_MONTH, 1);
            time = c.getTimeInMillis();
            level = MILLS[0];
        }  else {
            // 当前指定格式不支持
            return time;
        }
        if (scale <= Calendar.AM_PM) {
            // 获得时区偏移量
            offset = TimeZone.getDefault().getOffset(time);
        }
        return ((time + offset) / level) * level - offset;
    }

//  public static void main(String[] args) {
//      System.out.println(formatIntervalFrowNow(getEndTime(getSystemTime(), Calendar.DATE, 30), Calendar.DAY_OF_WEEK << 4 | Calendar.MINUTE, "还有", "结束"));
//  }
}
小奇奇丶八哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现时间转换器
weixin_61375386的博客
05-15 1253
使用java语言实现时，分，秒之间的相互转换： public class Time { private int hour;//时 private int minute;//分 private int second;//秒 public static void main(String[] args) { Time t=new Time(0,0,0); t.display(); t.addsecond(500); ..
Class -- 05 -- TimeUnit类常用方法解析
Gene Xu
08-12 3535
这次主要整理下Java中TimeUnit类的常用方法 一、TimeUnit类的定义 TimeUnit类是一个枚举类，主要用于时间颗粒度的转换与线程的延时 TimeUnit主要包含了以下几个枚举常量 SECONDS：秒 MINUTES：分 HOURS：时 DAYS：日 NANOSECONDS：纳秒，等于1∗10−9s1∗10−9s1 * 10^{-9}s MICROSECONDS：微秒，...
java整数(秒数)转换为时分秒格式
12-17
java整数(秒数)转换为时分秒格式
java中日期常用转换处理
New_Yao的博客
08-14 525
1.String转Date private void StringtoDate() throws ParseException { String dateStr = "2018-08-07 16:24:35"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); ...
java 时间处理 Date
一笑天
04-11 1365
1、java.util.Date类 Date 表示特定的瞬间，精确到毫秒。从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和分析日期字符串。Date 中的把日期解释为年、月、日、小时、分钟和秒值的方法已废弃。      }2、java.text.DateFormat（抽象类）DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许
Java时间日期格式转换
岁寒松柏
09-06 990
Java时间格式转换大全 import java.text.*; import java.util.Calendar; public class VeDate { /** * 获取现在时间 * * @return 返回时间类型 yyyy-MM-dd HH:mm:ss */ public static Date getNowDate() { D
JAVA时间日期处理类实例
09-03
在Java编程语言中，时间日期处理是常见的任务，涉及到对日期和时间的增减、比较、格式化等操作。在给定的实例中，我们看到了一个名为`AccountDate`的类，它提供了一些方法来处理日期相关的操作。下面将详细解释这个...
java时间相关处理小结
09-04
Java时间处理是编程中常见的需求，它涉及到日期和时间的计算、格式化和转换。...Java时间处理还包括处理时区、闰年判断、日期比较等多个方面，理解并熟练运用这些方法能够帮助开发者更有效地处理各种时间相关的任务。
java针对于时间转换的DateUtils工具类
08-28
Java 中的 DateUtils 工具类是 Java 语言中的一种常用工具类，用于处理日期和时间的转换。该工具类提供了多种日期和时间的转换方法，包括 String 转 Timestamp、String 转 Date、Date 转 String、Date 转 Timestamp ...
详解JAVA 时间处理相关类
08-18
Java 时间处理相关类详解 Java 时间处理相关类是 Java 语言中处理时间相关操作的基础类库。这些类提供了丰富的时间处理功能，包括时间对象的创建、格式化、比较、计算等。下面将详细介绍 Java 时间处理相关类的知识...
java整数(秒数)转换为时分秒格式的示例
09-04
主要介绍了java整数(秒数)转换为时分秒格式的示例,需要的朋友可以参考下
Java 时间转换的实例代码
09-02
本文将通过一个实例代码详细讲解如何在Java中进行时间转换。 首先，Java提供了`java.util.Date`、`java.util.Calendar`和`java.text.SimpleDateFormat`等类来处理日期和时间。在上述代码中，我们主要使用了`...
JAVA进阶教学之（Date日期的处理）
LBJ8888888的博客
03-16 178
两个类： Date类：获取系统当前日期，属于java.util.Date包内 SimpleDateFormat类：将当前日期进行格式化处理，yyy-MM-dd HH:mm:ss SSS 代码演示： Date转String package com.lbj.javase.date; import java.text.SimpleDateFormat; import java.util.Date; public class DateTest01 { public stati..
java中时间的转换工具
weixin_45642572的博客
01-15 344
java中时间的转换工具类 import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /** * @Author 小袁兄弟 * @Date: 2021/1/2 15:29 * @QQ：1758906065 * @Aphorism: * 苦心人天不负，自助者天助！ * 实践是检验真理的唯一标准。 */ /** * 时间转换的工具 */ public class Da
Java时间格式转换大全
xiaojian_708的专栏
07-01 293
<br />Java时间格式转换大全<br />import java.text.*;<br /> import java.util.Calendar;<br /> public class VeDate {<br /> /**<br /> * 获取现在时间<br /> * <br /> * @return 返回时间类型 yyyy-MM-dd HH:mm:ss<br /> */<br /> public static Date getNowDate() {<br /> D
Java关于时间的处理（Date，SimpleDateFormat）
pfxfly的博客
02-18 303
Date表示时刻，内部主要是一个long型的值，如下 private transient long fastTime;//fastTime表示的是距离纪元1900年1月1日0时0分0秒的毫秒数 Date有两个构造方法： public Date() { this(System.currentTimeMillis()); }//默认构造方法，根据System.cur...
Java中Date类以及对时间的一些相关处理（纯纯）
MsXintu的博客
11-05 274
Java中Date类以及对时间的一些相关知识
Android时间工具类
最新发布
小北的博客
07-14 519
时间在软件开发中是一个常见的处理需求，包括获取当前时间、时间格式化、时间比较、时间差计算等操作。为了简化开发过程，可以编写一个时间工具类来封装这些常用的时间操作方法。
java时间格式转换
05-27
以下是一个示例程序，将字符串类型的时间转换为指定格式的日期时间： ```java import java.text.SimpleDateFormat; import java.util.Date; public class DateFormatExample { public static void main(String[] ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值