Android获取当前时间的年周月季度等的开始结束时间

原创 已于 2022-08-02 10:37:00 修改 · 2.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#日期工具类 #dateTime #TimeUtil #DateUtil

于 2022-06-22 10:20:42 首次发布
本文介绍了如何在Android中使用DateUtil、DateTimeUtil和DatetimeUtil工具类来获取当前时间的年、半年、季度、月、日、小时的开始和结束时间，提供了相关代码示例。
  • 获取 当前年、半年、季度、月、日、小时 开始结束时间
  • 时间处理工具类

1、DateUtil.java


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * @Dec ：
 * @Author : Caowj
 * @Date : 2018/11/13 15:11
 */
public class DateUtil {
    private static final String DATE_PATTERN_1 = "yyyy-MM-dd HH:mm:ss";
    private static final String DATE_PATTERN_2 = "yyyy-MM-dd";
    private static final String DATE_PATTERN_3 = "yyyyMMddHHmmss";//不包含毫秒
    private static final String DATE_PATTERN_4 = "yyyyMMddHHmmssSSS";//包含毫秒
    private static final String DATE_PATTERN_5 = "HH:mm:ss";
    private static final String DATE_PATTERN_6 = "yyyy/MM/dd";

    /**
     * 计算某日期所在季度开始日期
     * 季度划分：1、2、3， 4、5、6， 7、8、9， 10、11、12
     */
    public static Date getSeasonEndDate (Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int month = calendar.get(Calendar.MONTH);
        calendar.set(Calendar.MONTH, (month + 3) / 3 * 3);
        calendar.set(Calendar.DATE, 1);
        return new Date(calendar.getTime().getTime() - 24 * 60 * 60 *1000);
    }
    /**
     * 计算某日期所在季度结束日期
     * 季度划分：1、2、3， 4、5、6， 7、8、9， 10、11、12
     */
    public static Date getSeasonStartDate (Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int month = calendar.get(Calendar.MONTH);
        calendar.set(Calendar.MONTH, month / 3 * 3);
        calendar.set(Calendar.DATE, 1);
        return calendar.getTime();
    }



    /**
     * 获取当月第一天
     *
     * @return
     */
    public static long getThisMonthFirstDay() {
//        SimpleDateFormat format = new SimpleDateFormat(DATE_PATTERN_2);
//        String firstday;
        // 获取前月的第一天
        Calendar cale = Calendar.getInstance();
        cale = Calendar.getInstance();
        cale.add(Calendar.MONTH, 0);
        cale.set(Calendar.DAY_OF_MONTH, 1);
//        firstday = format.format(cale.getTime());
        return cale.getTimeInMillis();
    }

    /**
     * 获取当月最后一天
     *
     * @return
     */
    public static long getThisMonthLastDay() {
        // 获取前月的最后一天
        Calendar cale = Calendar.getInstance();
        cale.add(Calendar.MONTH, 1);
        cale.set(Calendar.DAY_OF_MONTH, 0);
        return cale.getTimeInMillis();
    }


    /**
     * 获取本周第一天
     *
     * @return
     */
    public static long getTisWeekFirstDay() {
        Calendar cal = Calendar.getInstance();
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // System.out.println("要计算日期为:" + sdf.format(cal.getTime())); // 输出要计算日期
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);

        return cal.getTimeInMillis();
    }

    /**
     * 获取本周最后一天
     *
     * @return
     */
    public static long getTisWeekLastDay() {
        Calendar cal = Calendar.getInstance();
        // 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        cal.add(Calendar.DATE, 6);
        return cal.getTimeInMillis();
    }

    /**
     * 获取过去第几天的日期
     *
     * @param past
     * @return
     */
    public static long getPastDate(int past) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - past);
        return calendar.getTimeInMillis();
    }

    /**
     * 获取当天的日期
     *
     * @return
     */
    public static long getCurrentDay() {
        Calendar calendar = Calendar.getInstance();
        return calendar.getTimeInMillis();
    }

    /**
     * 当前时间
     *
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentDayStr() {
        return getFormatDateTime(getCurrentDay(), DATE_PATTERN_3);
    }

    /**
     * 转换时间格式
     * <p>
     *
     * @param strTime yyyyMMddHHmmssSSS 或者 yyyyMMddHHmmss
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String formatDateString(String strTime) {
        SimpleDateFormat oldFormat;
        if (strTime != null && strTime.length() == 17) {
            oldFormat = new SimpleDateFormat(DATE_PATTERN_4, Locale.CHINA);
        } else {
            oldFormat = new SimpleDateFormat(DATE_PATTERN_3, Locale.CHINA);
        }

        SimpleDateFormat newFormat = new SimpleDateFormat(DATE_PATTERN_1, Locale.CHINA);
        try {
            Date date = oldFormat.parse(strTime);
            return newFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 获取格式化后的日期
     *
     * @param strTime yyyyMMddHHmmssSSS 或者 yyyyMMddHHmmss
     * @return yyyy-MM-dd
     */
    public static String getFormatDate(String strTime) {
        SimpleDateFormat oldFormat;
        if (strTime != null && strTime.length() == 17) {
            oldFormat = new SimpleDateFormat(DATE_PATTERN_4, Locale.CHINA);
        } else {
            oldFormat = new SimpleDateFormat(DATE_PATTERN_3, Locale.CHINA);
        }

        SimpleDateFormat newFormat = new SimpleDateFormat(DATE_PATTERN_2, Locale.CHINA);
        try {
            Date date = oldFormat.parse(strTime);
            return newFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * @param dateTime
     * @param format
     * @return
     */
    public static String getFormatDateTime(long dateTime, String format) {

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        Date date = new Date(dateTime);
        return simpleDateFormat.format(date);
    }


    /**
     * @param date
     * @return yyyy-MM-dd
     */
    public static String getFormatDate(Date date) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat format = new SimpleDateFormat(DATE_PATTERN_2);
        return format.format(date);
    }

    /**
     * 获取格式化后的时间
     *
     * @param strTime yyyyMMddHHmmssSSS 或者 yyyyMMddHHmmss
     * @return HH:mm:ss
     */
    public static String getFormatTime(String strTime) {
        SimpleDateFormat oldFormat;
        if (strTime != null && strTime.length() == 17) {
            oldFormat = new SimpleDateFormat(DATE_PATTERN_4, Locale.CHINA);
        } else {
            oldFormat = new SimpleDateFormat(DATE_PATTERN_3, Locale.CHINA);
        }

        SimpleDateFormat newFormat = new SimpleDateFormat(DATE_PATTERN_5, Locale.CHINA);
        try {
            Date date = oldFormat.parse(strTime);
            return newFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 转换成时间戳
     *
     * @param dateStr yyyyMMddHHmmss
     * @return
     */
    public static long String2Long(String dateStr) {
        return String2Long(dateStr, DATE_PATTERN_3);
    }

    /**
     * 自定义，转换成时间戳
     *
     * @param dateStr
     * @param dateFormat
     * @return
     */
    public static long String2Long(String dateStr, String dateFormat) {
        SimpleDateFormat format = new SimpleDateFormat(dateFormat, Locale.CHINA);
        Date date = null;
        try {
            date = format.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        if (date != null) {
            return date.getTime();
        } else {
            return 0;
        }
    }


    /**
     * 时间戳转换成固定格式
     *
     * @param dateLong
     * @return yyyy-MM-dd
     */
    public static String Long2String(long dateLong) {
        return Long2String(dateLong, DATE_PATTERN_2);
    }

    /**
     * 时间戳转换成固定格式
     *
     * @param dateLong
     * @return yyyy/MM/dd
     */
    public static String Long3String(long dateLong) {
        return Long2String(dateLong, DATE_PATTERN_6);
    }

    /**
     * @param dateLong
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String Long2String1(long dateLong) {
        return Long2String(dateLong, DATE_PATTERN_1);
    }

    /**
     * 自定义，时间戳转换成指定格式
     *
     * @param dateLong
     * @param dateFormat
     * @return
     */
    public static String Long2String(long dateLong, String dateFormat) {
        Date date = new Date(dateLong);
        SimpleDateFormat format = new SimpleDateFormat(dateFormat, Locale.CHINA);
        return format.format(date);
    }
}

2、DateTimeUtil.java (荐)


/**
 * <pre>
 *     https://blog.youkuaiyun.com/qq_18671415/article/details/118185797
 * </pre>
 */
import android.annotation.SuppressLint;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

@SuppressLint("SimpleDateFormat")
public class TimeUtil {
    /**
     * 获取 当前年、半年、季度、月、日、小时 开始结束时间
     */
    private final static SimpleDateFormat shortSdf = new SimpleDateFormat("yyyy-MM-dd");
    private final static SimpleDateFormat longHourSdf = new SimpleDateFormat("yyyy-MM-dd HH");
    private final static SimpleDateFormat longSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//    public static void main(String[] args) {
//        System.out.println("当前小时开始：" + getCurrentHourStartTime().toString());
//        System.out.println("当前小时结束：" + getCurrentHourEndTime().toString());
//        System.out.println("当前天开始：" + getCurrentDayStartTime().toString());
//        System.out.println("当前天时结束：" + getCurrentDayEndTime().toString());
//        System.out.println("当前周开始：" + getCurrentWeekDayStartTime());
//        System.out.println("当前周结束：" + getCurrentWeekDayEndTime());
//        System.out.println("当前月开始：" + getCurrentMonthStartTime().toString());
//        System.out.println("当前月结束：" + getCurrentMonthEndTime().toString());
//        System.out.println("当前季度开始：" + getCurrentQuarterStartTime().toString());
//        System.out.println("当前季度结束：" + getCurrentQuarterEndTime().toString());
//        System.out.println("当前半年/后半年开始：" + getHalfYearStartTime().toString());
//        System.out.println("当前半年/后半年结束：" + getHalfYearEndTime().toString());
//        System.out.println("当前年开始：" + getCurrentYearStartTime().toString());
//        System.out.println("当前年结束：" + getCurrentYearEndTime().toString());
//    }

    /**
     * 获得本周的第一天，周一
     */
    public static Date getCurrentWeekDayStartTime() {
        Calendar c = Calendar.getInstance();
        try {
            int weekday = c.get(Calendar.DAY_OF_WEEK) - 2;
            c.add(Calendar.DATE, -weekday);
            c.setTime(longSdf.parse(shortSdf.format(c.getTime()) + " 00:00:00"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return c.getTime();
    }

    /**
     * 获得本周的最后一天，周日
     */
    public static Date getCurrentWeekDayEndTime() {
        Calendar c = Calendar.getInstance();
        try {
            int weekday = c.get(Calendar.DAY_OF_WEEK);
            c.add(Calendar.DATE, 8 - weekday);
            c.setTime(longSdf.parse(shortSdf.format(c.getTime()) + " 23:59:59"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return c.getTime();
    }

    /**
     * 获得本天的开始时间
     */
    public static Date getCurrentDayStartTime() {
        Date now = new Date();
        try {
            now = shortSdf.parse(shortSdf.format(now));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 获得本天的结束时间
     */
    public static Date getCurrentDayEndTime() {
        Date now = new Date();
        try {
            now = longSdf.parse(shortSdf.format(now) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 获得本小时的开始时间
     */
    public static Date getCurrentHourStartTime() {
        Date now = new Date();
        try {
            now = longHourSdf.parse(longHourSdf.format(now));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 获得本小时的结束时间
     */
    public static Date getCurrentHourEndTime() {
        Date now = new Date();
        try {
            now = longSdf.parse(longHourSdf.format(now) + ":59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 获得本月的开始时间
     */
    public static Date getCurrentMonthStartTime() {
        Calendar c = Calendar.getInstance();
        Date now = null;
        try {
            c.set(Calendar.DATE, 1);
            now = shortSdf.parse(shortSdf.format(c.getTime()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 本月的结束时间
     */
    public static Date getCurrentMonthEndTime() {
        Calendar c = Calendar.getInstance();
        Date now = null;
        try {
            c.set(Calendar.DATE, 1);
            c.add(Calendar.MONTH, 1);
            c.add(Calendar.DATE, -1);
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 当前年的开始时间
     */
    public static Date getCurrentYearStartTime() {
        Calendar c = Calendar.getInstance();
        Date now = null;
        try {
            c.set(Calendar.MONTH, 0);
            c.set(Calendar.DATE, 1);
            now = shortSdf.parse(shortSdf.format(c.getTime()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 当前年的结束时间
     */
    public static Date getCurrentYearEndTime() {
        Calendar c = Calendar.getInstance();
        Date now = null;
        try {
            c.set(Calendar.MONTH, 11);
            c.set(Calendar.DATE, 31);
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 当前季度的开始时间
     */
    public static Date getCurrentQuarterStartTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        Date now = null;
        try {
            if (currentMonth >= 1 && currentMonth <= 3)
                c.set(Calendar.MONTH, 0);
            else if (currentMonth >= 4 && currentMonth <= 6)
                c.set(Calendar.MONTH, 3);
            else if (currentMonth >= 7 && currentMonth <= 9)
                c.set(Calendar.MONTH, 4);
            else if (currentMonth >= 10 && currentMonth <= 12)
                c.set(Calendar.MONTH, 9);
            c.set(Calendar.DATE, 1);
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 00:00:00");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 当前季度的结束时间
     */
    public static Date getCurrentQuarterEndTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        Date now = null;
        try {
            if (currentMonth >= 1 && currentMonth <= 3) {
                c.set(Calendar.MONTH, 2);
                c.set(Calendar.DATE, 31);
            } else if (currentMonth >= 4 && currentMonth <= 6) {
                c.set(Calendar.MONTH, 5);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 7 && currentMonth <= 9) {
                c.set(Calendar.MONTH, 8);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 10 && currentMonth <= 12) {
                c.set(Calendar.MONTH, 11);
                c.set(Calendar.DATE, 31);
            }
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 获取前/后半年的开始时间
     */
    public static Date getHalfYearStartTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        Date now = null;
        try {
            if (currentMonth >= 1 && currentMonth <= 6) {
                c.set(Calendar.MONTH, 0);
            } else if (currentMonth >= 7 && currentMonth <= 12) {
                c.set(Calendar.MONTH, 6);
            }
            c.set(Calendar.DATE, 1);
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 00:00:00");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;

    }

    /**
     * 获取前/后半年的结束时间
     */
    public static Date getHalfYearEndTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        Date now = null;
        try {
            if (currentMonth >= 1 && currentMonth <= 6) {
                c.set(Calendar.MONTH, 5);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 7 && currentMonth <= 12) {
                c.set(Calendar.MONTH, 11);
                c.set(Calendar.DATE, 31);
            }
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }
}

3、DatetimeUtil.kt （荐）

import android.content.Context
import android.os.Build.VERSION.SDK_INT
import java.text.ParseException
import java.text.ParsePosition
import java.text.SimpleDateFormat
import java.util.*
import java.util.regex.Pattern

/**
 * 时间处理工具类
 */
object DatetimeUtil {

    /**
     *  格式：年－月－日 小时：分钟：秒
     */
    @JvmField
    val FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND = "yyyy-MM-dd HH:mm:ss"

    /**
     * 格式：年－月－日 小时：分钟
     */
    @JvmField
    val FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE = "yyyy-MM-dd HH:mm"

    /**
     * 格式：年－月－日
     */
    @JvmField
    val FORMAT_YEAR_MONTH_DAY = "yyyy-MM-dd"

    /**
     * 格式：月－日
     */
    @JvmField
    val FORMAT_MONTH_DAY = "MM-dd"

    /**
     *  格式：小时：分钟：秒
     */
    @JvmField
    val FORMAT_HOUR_MINUTE_SECOND = "HH:mm:ss"

    /**
     * 格式：小时 ：分钟
     */
    @JvmField
    val FORMAT_HOUR_MINUTE = "HH:mm"

    /**
     * 年的加减
     */
    @JvmField
    val SUB_YEAR = if (SDK_INT < 24) Calendar.YEAR else android.icu.util.Calendar.YEAR

    /**
     * 月加减
     */
    @JvmField
    val SUB_MONTH = if (SDK_INT < 24) Calendar.MONTH else android.icu.util.Calendar.MONTH

    /**
     * 天的加减
     */
    @JvmField
    val SUB_DAY = if (SDK_INT < 24) Calendar.DATE else android.icu.util.Calendar.DATE

    /**
     * 小时的加减
     */
    @JvmField
    val SUB_HOUR = if (SDK_INT < 24) Calendar.HOUR else android.icu.util.Calendar.HOUR

    /**
     * 分钟的加减
     */
    @JvmField
    val SUB_MINUTE = if (SDK_INT < 24) Calendar.MINUTE else android.icu.util.Calendar.MINUTE

    /**
     * 秒的加减
     */
    @JvmField
    val SUB_SECOND = if (SDK_INT < 24) Calendar.SECOND else android.icu.util.Calendar.SECOND

    @JvmField
    val dayNames = arrayOf("", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六")

    /**
     * 时间格式
     */
    @JvmStatic
    private val mTimeFormat = if (SDK_INT < 24)
        java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
    else
        android.icu.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

    /**
     * 把符合日期格式的String转换为Date对象
     *
     * @param dateStr 日期字符串
     * @param format 格式
     * @return 格式
     */
    @JvmStatic
    fun stringToDate(dateStr: String, format: String): Date? {
        return try {
            if (SDK_INT < 24) {
                val formatter = java.text.SimpleDateFormat(format, Locale.getDefault())
                formatter.calendar.isLenient = false
                formatter.parse(dateStr)
            } else {
                val formatter = android.icu.text.SimpleDateFormat(format, Locale.getDefault())
                formatter.isLenient = false
                formatter.parse(dateStr)
            }
        } catch (e: Exception) {
            // log.error(e);
            null
        }
    }

    /**
     * 把符合日期格式的字符串转换为日期类型，从pos位置开始解析
     */
    @JvmStatic
    fun stringToDate(dateStr: String, format: String, pos: ParsePosition): Date? {
        return if (SDK_INT < 24) {
            val formatter = java.text.SimpleDateFormat(format, Locale.getDefault())
            formatter.calendar.isLenient = false
            formatter.parse(dateStr, pos)
        } else {
            val formatter = android.icu.text.SimpleDateFormat(format)
            formatter.isLenient = false
            formatter.parse(dateStr, pos)
        }
    }

    /**
     * 把日期转换为字符串
     *
     * @param date
     * @return
     */
    @JvmStatic
    fun dateToString(date: Date, format: String): String {
        var result = ""
        val formatter = if (SDK_INT < 24)
            java.text.SimpleDateFormat(format, Locale.getDefault())
        else
            android.icu.text.SimpleDateFormat(format)
        try {
            result = formatter.format(date)
        } catch (e: Exception) {
            // log.error(e);
        }

        return result
    }

    /**
     * 获取当前时间的指定格式
     *
     * @param format 格式字符串， 例如："yyyy-MM-dd HH:mm:ss"
     * @return format格式的字符串
     */
    @JvmStatic
    fun getCurrDate(format: String): String {
        return dateToString(Date(), format)
    }

    /**
     * 依据Calendar规则对日期进行增减操作。
     * 此方法默认按照"yyyy-MM-dd HH:mm:ss"转换为Date类型，进行日期的增减后返回String格式。
     *
     * @param dateKind 日期类型，例如：Calendar.DAY_OF_MONTH
     * @param dateStr 日期字符串格式
     * @param amount 增减的量值
     * @return
     */
    @JvmStatic
    fun dateSub(dateKind: Int, dateStr: String, amount: Int): String {
        val date = stringToDate(dateStr, FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
        return if (SDK_INT < 24) {
            val calendar = Calendar.getInstance()
            calendar.time = date
            calendar.add(dateKind, amount)
            dateToString(calendar.time, FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
        } else {
            val calendar = android.icu.util.Calendar.getInstance()
            calendar.time = date
            calendar.add(dateKind, amount)
            dateToString(calendar.time, FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
        }
    }

    /**
     * 两个日期相减
     *
     * @param firstTime 第一个日期
     * @param secTime 第二个日期
     * @return 相减得到的秒数
     */
    @JvmStatic
    fun timeSubtraction(firstTime: String, secTime: String): Long {
        val first = stringToDate(firstTime, FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)!!.time
        val second = stringToDate(secTime, FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)!!.time
        return (second - first) / 1000
    }

    /**
     * 获得某月的天数
     *
     * @param year 年
     *
     * @param month 月份
     *
     * @return int
     */
    @JvmStatic
    fun getDaysOfMonth(year: String, month: String): Int {
        var days = 0
        if (month == "1" || month == "3" || month == "5"
                || month == "7" || month == "8" || month == "10"
                || month == "12") {
            days = 31
        } else if (month == "4" || month == "6" || month == "9"
                || month == "11") {
            days = 30
        } else {
            if (Integer.parseInt(year) % 4 == 0 && Integer.parseInt(year) % 100 != 0 || Integer.parseInt(year) % 400 == 0) {
                days = 29
            } else {
                days = 28
            }
        }

        return days
    }

    /**
     * 获取某年某月的天数
     *
     * @param year
     * int
     * @param month
     * int 月份[1-12]
     * @return int
     */
    @JvmStatic
    fun getDaysOfMonth(year: Int, month: Int): Int {
        val calendar = Calendar.getInstance()
        calendar.set(year, month - 1, 1)
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH)
    }

    /**
     * 获得当前月份的第几天，例如：11/5 => 5。
     * 每月第一天值为1。
     *
     * @return int
     */
    @JvmStatic
    fun getToday(): Int {
        val calendar = Calendar.getInstance()
        return calendar.get(Calendar.DATE)
    }

    /**
     * 获得当前月份
     *
     * @return int
     */
    @JvmStatic
    fun getMonth(): Int {
        val calendar = Calendar.getInstance()
        return calendar.get(Calendar.MONTH) + 1
    }

    /**
     * 获得当前年份
     *
     * @return int
     */
    @JvmStatic
    fun getYear(): Int {
        val calendar = Calendar.getInstance()
        return calendar.get(Calendar.YEAR)
    }

    /**
     * 给定日期，获取日期中Day值。功能类似getToday()方法。
     *
     * @param date
     * Date
     * @return int
     */
    @JvmStatic
    fun getDay(date: Date): Int {
        val calendar = Calendar.getInstance()
        calendar.time = date
        return calendar.get(Calendar.DATE)
    }

    /**
     * 返回日期的年
     *
     * @param date
     * Date
     * @return int
     */
    @JvmStatic
    fun getYear(date: Date?): Int {
        val calendar = Calendar.getInstance()
        calendar.time = date
        return calendar.get(Calendar.YEAR)
    }

    /**
     * 返回日期的月份，1-12
     *
     * @param date
     * Date
     * @return int
     */
    @JvmStatic
    fun getMonth(date: Date): Int {
        val calendar = Calendar.getInstance()
        calendar.time = date
        return calendar.get(Calendar.MONTH) + 1
    }

    /**
     * 计算两个日期相差的天数，如果date2 > date1 返回正数，否则返回负数
     *
     * @param date1
     * Date
     * @param date2
     * Date
     * @return long
     */
    @JvmStatic
    fun dayDiff(date1: Date, date2: Date): Long {
        return (date2.time - date1.time) / 86400000
    }

    /**
     * 比较两个日期的年差
     *
     * @param befor
     * @param after
     * @return
     */
    @JvmStatic
    fun yearDiff(before: String, after: String): Int {
        val beforeDay = stringToDate(before, FORMAT_YEAR_MONTH_DAY)
        val afterDay = stringToDate(after, FORMAT_YEAR_MONTH_DAY)
        return getYear(afterDay) - getYear(beforeDay)
    }

    /**
     * 比较指定日期与当前日期的差
     *
     * @param befor
     * @param after
     * @return
     */
    @JvmStatic
    fun yearDiffCurr(after: String): Int {
        val beforeDay = Date()
        val afterDay = stringToDate(after, FORMAT_YEAR_MONTH_DAY)
        return getYear(beforeDay) - getYear(afterDay)
    }

    /**
     * 比较指定日期与当前日期的差
     * @param before
     * @return
     */
    @JvmStatic
    fun dayDiffCurr(before: String): Long? {
        val currDate = stringToDate(currDay(), FORMAT_YEAR_MONTH_DAY)
        val beforeDate = stringToDate(before, FORMAT_YEAR_MONTH_DAY)
        return currDate?.time?.minus(beforeDate!!.time)?.div(86400000)

    }

    /**
     * 获取某月第一天的dayOfWeek值，星期天(1) ... 星期六(7)。
     *
     * @param year
     * @param month
     * @return
     */
    @JvmStatic
    fun getFirstWeekdayOfMonth(year: Int, month: Int): Int {
        val c = Calendar.getInstance()
        c.firstDayOfWeek = Calendar.SUNDAY // 星期天为第一天
        c.set(year, month - 1, 1)
        return c.get(Calendar.DAY_OF_WEEK)
    }

    /**
     * 获取某每月的最后一天的dayOfWeek值，星期天(1) ... 星期六(7)。
     *
     * @param year
     * @param month
     * @return
     */
    @JvmStatic
    fun getLastWeekdayOfMonth(year: Int, month: Int): Int {
        val c = Calendar.getInstance()
        c.firstDayOfWeek = Calendar.SATURDAY // 星期天为第一天
        c.set(year, month - 1, getDaysOfMonth(year, month))
        return c.get(Calendar.DAY_OF_WEEK)
    }

    /**
     * 获得当前日期字符串，格式"yyyy_MM_dd_HH_mm_ss"，单位数补0处理。例如：2019_11_05_18_49_52
     *
     * @return
     */
    @JvmStatic
    fun getCurrent(): String {
        val cal = Calendar.getInstance()
        cal.time = Date()
        val year = cal.get(Calendar.YEAR)
        val month = cal.get(Calendar.MONTH) + 1
        val day = cal.get(Calendar.DAY_OF_MONTH)
        val hour = cal.get(Calendar.HOUR_OF_DAY)
        val minute = cal.get(Calendar.MINUTE)
        val second = cal.get(Calendar.SECOND)
        val sb = StringBuffer()
        sb.append(year).append("_").append(addzero(month, 2))
                .append("_").append(addzero(day, 2)).append("_")
                .append(addzero(hour, 2)).append("_").append(
                        addzero(minute, 2)).append("_").append(
                        addzero(second, 2))
        return sb.toString()
    }

    /**
     * 获得当前日期字符串，格式"yyyy-MM-dd HH:mm:ss"。
     *
     * @return
     */
    @JvmStatic
    fun getNow(): String {
        val today = Calendar.getInstance()
        return dateToString(today.time, FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
    }

    /**
     * 判断日期是否有效,包括闰年的情况
     *
     * @param date
     * YYYY-mm-dd
     * @return
     */
    @JvmStatic
    fun isDate(date: String): Boolean {
        val reg = StringBuffer(
                "^((\\d{2}(([02468][048])|([13579][26]))-?((((0?")
        reg.append("[13578])|(1[02]))-?((0?[1-9])|([1-2][0-9])|(3[01])))")
        reg.append("|(((0?[469])|(11))-?((0?[1-9])|([1-2][0-9])|(30)))|")
        reg.append("(0?2-?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][12")
        reg.append("35679])|([13579][01345789]))-?((((0?[13578])|(1[02]))")
        reg.append("-?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))")
        reg.append("-?((0?[1-9])|([1-2][0-9])|(30)))|(0?2-?((0?[")
        reg.append("1-9])|(1[0-9])|(2[0-8]))))))")
        val p = Pattern.compile(reg.toString())
        return p.matcher(date).matches()
    }

    /**
     * 取得指定日期过 months 月后的日期 (当 months 为负数表示指定月之前);
     *
     * @param date
     * 日期 为null时表示当天
     * @param month
     * 相加(相减)的月数
     */
    @JvmStatic
    fun nextMonth(date: Date?, months: Int): Date {
        val cal = Calendar.getInstance()
        if (date != null) {
            cal.time = date
        }
        cal.add(Calendar.MONTH, months)
        return cal.time
    }

    /**
     * 取得指定日期过 day 天后的日期 (当 day 为负数表示指日期之前);
     *
     * @param date 日期 为null时表示当天
     * @param day 相加(相减)的月数
     */
    @JvmStatic
    fun nextDay(date: Date?, day: Int): Date {
        val cal = Calendar.getInstance()
        if (date != null) {
            cal.time = date
        }
        cal.add(Calendar.DAY_OF_YEAR, day)
        return cal.time
    }

    /**
     * 取得距离今天 day 日的日期
     * @param day
     * @param format
     * @return
     */
    @JvmStatic
    fun nextDay(day: Int, format: String): String {
        val cal = Calendar.getInstance()
        cal.time = Date()
        cal.add(Calendar.DAY_OF_YEAR, day)
        return dateToString(cal.time, format)
    }

    /**
     * 取得指定日期过 week 周后的日期 (当 week 为负数表示指定月之前)
     *
     * @param date 日期 为null时表示当天
     * @param week week周
     */
    @JvmStatic
    fun nextWeek(date: Date?, week: Int): Date {
        val cal = Calendar.getInstance()
        if (date != null) {
            cal.time = date
        }
        cal.add(Calendar.WEEK_OF_MONTH, week)
        return cal.time
    }

    /**
     * 获取当前的日期(yyyy-MM-dd)
     */
    @JvmStatic
    fun currDay(): String {
        return dateToString(Date(), FORMAT_YEAR_MONTH_DAY)
    }

    /**
     * 获取昨天的日期
     *
     * @return
     */
    @JvmStatic
    fun yesterday(): String {
        return yesterday(FORMAT_YEAR_MONTH_DAY)
    }

    /**
     * 根据时间类型获取昨天的日期
     * @param format
     * @return
     */
    @JvmStatic
    fun yesterday(format: String): String {
        return dateToString(nextDay(Date(), -1), format)
    }

    /**
     * 获取明天的日期
     */
    @JvmStatic
    fun tomorrow(): String {
        return dateToString(nextDay(Date(), 1), FORMAT_YEAR_MONTH_DAY)
    }

    /**
     * 取得当前时间距离1900/1/1的天数
     *
     * @return
     */
    @JvmStatic
    fun getDayNum(): Int {
        var daynum = 0
        val gd = GregorianCalendar()
        val dt = gd.time
        val gd1 = GregorianCalendar(1900, 1, 1)
        val dt1 = gd1.time
        daynum = ((dt.time - dt1.time) / (24 * 60 * 60 * 1000)).toInt()
        return daynum
    }

    /**
     * getDayNum的逆方法(用于处理Excel取出的日期格式数据等)
     *
     * @param day
     * @return
     */
    @JvmStatic
    fun getDateByNum(day: Int): Date {
        val gd = GregorianCalendar(1900, 1, 1)
        var date = gd.time
        date = nextDay(date, day)
        return date
    }

    /**
     *  针对yyyy-MM-dd HH:mm:ss格式,显示yyyymmdd
     */
    @JvmStatic
    fun getYmdDateCN(datestr: String?): String {
        if (datestr == null)
            return ""
        if (datestr.length < 10)
            return ""
        val buf = StringBuffer()
        buf.append(datestr.substring(0, 4)).append(datestr.substring(5, 7))
                .append(datestr.substring(8, 10))
        return buf.toString()
    }

    /**
     * 获取本月第一天
     *
     * @param format
     * @return
     */
    @JvmStatic
    fun getFirstDayOfMonth(format: String): String {
        val cal = Calendar.getInstance()
        cal.set(Calendar.DATE, 1)
        return dateToString(cal.time, format)
    }

    /**
     * 获取本月最后一天
     *
     * @param format
     * @return
     */
    @JvmStatic
    fun getLastDayOfMonth(format: String): String {
        val cal = Calendar.getInstance()
        cal.set(Calendar.DATE, 1)
        cal.add(Calendar.MONTH, 1)
        cal.add(Calendar.DATE, -1)
        return dateToString(cal.time, format)
    }

    /**
     * 将元数据前补零，补后的总长度为指定的长度，以字符串的形式返回
     * @param sourceDate
     * @param formatLength
     * @return 重组后的数据
     */
    @JvmStatic
    fun addzero(sourceDate: Int, formatLength: Int): String {
        /*
      * 0 指前面补充零
      * formatLength 字符总长度为 formatLength
      * d 代表为正数。
      */
        return String.format("%0" + formatLength + "d", sourceDate)
    }


    /**
     *
     * 获取当前是星期几
     *
     * @return 星期几
     */
    @JvmStatic
    fun getWeek(): String {
        val cal = Calendar.getInstance()
        return dayNames[cal.get(Calendar.DAY_OF_WEEK)]
    }

    /**
     *
     * 根据十二小时制或者二十四小时制得到时间
     *
     * @return 时间
     */
    @JvmStatic
    fun getCurrentTimeBy12_24(context: Context): String {
        if (android.text.format.DateFormat.is24HourFormat(context)) {
            return getCurrDate(FORMAT_HOUR_MINUTE)
        } else {
            val sb = StringBuilder()
            val hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
            val minute = Calendar.getInstance().get(Calendar.MINUTE)
            if (hour >= 12) {
                sb.append(hour - 12).append(":").append(minute).append(" PM")
            } else {
                sb.append(hour).append(":").append(minute).append(" AM")
            }
            return sb.toString()
        }
    }
/*******************以下是合并来的*********************************/
    /**
     * 转换日期格式,如"1694-1-1 10:23:4" 转成"11694-01-01 10:23:04"
     * @param strTime
     * @return
     */
    @JvmStatic
    fun formatDateString(strTime: String): String {
        val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
        try {
            val date = formatter.parse(strTime)
            return formatter.format(date)
        } catch (e: ParseException) {
            e.printStackTrace()
        }

        return ""
    }

    /**
     * 转换Date对象为yyyy-MM-dd HH:mm:ss格式的字符串
     * @param date
     * @return
     */
    @JvmStatic
    fun dateToLongStr(date: java.util.Date?): String? {
        if (date == null) {
            return null
        }
        val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
        return formatter.format(date)
    }

    /**
     * 转换Date对象为yyyy-MM-dd"格式的字符串
     * @param date
     * @return
     */
    @JvmStatic
    fun dateToDayStr(date: java.util.Date?): String? {
        if (date == null) {
            return null
        }
        val formatter = SimpleDateFormat("yyyy-MM-dd")
        return formatter.format(date)
    }

    /**
     * 转换日期字符串为Date对象
     * @param strDate 1986-01-15或者2018-05-15 14:20:56格式的字符串
     * @return
     */
    @JvmStatic
    fun strToDate(strDate: String): Date? {
        var formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
        val pos = ParsePosition(0)
        var strtodate: Date? = formatter.parse(strDate, pos)
        if (strtodate == null) {
            formatter = SimpleDateFormat("yyyy-MM-dd")
            strtodate = formatter.parse(strDate, pos)
        }
        return strtodate
    }

    /**
     * 时间戳（毫秒数）转成yyyy-MM-dd HH:mm:ss格式的日期字符串
     * @param value
     * @return
     */
    @JvmStatic
    fun timestampToLongDateStr(value: Long?): String? {
        val date = if (value == null) null else Date(value)
        return dateToLongStr(date)
    }

    /**
     * 时间戳（毫秒数）转成yyyy-MM-dd格式的日期字符串
     * @param value
     * @return
     */
    @JvmStatic
    fun timestampToDateStr(value: Long?): String? {
        val date = if (value == null) null else Date(value)
        return dateToDayStr(date)
    }

    /**
     * yyyy-MM-dd HH:mm:ss或yyyy-MM-dd 格式的时间字符串转成时间戳（毫秒数）
     * @param strDate
     * @return
     */
    @JvmStatic
    fun dateStrToTimestamp(strDate: String): Long? {
        val date = strToDate(strDate)
        return if (date == null) null else date!!.getTime()
    }
}

4、获取时间范围

测试代码：
//    LegoLog.d(getDateRange(1).toStr())
//    LegoLog.d(getDateRange(2).toStr())
//    LegoLog.d(getDateRange(3).toStr())
//    LegoLog.d(getDateRange(4).toStr())
//    LegoLog.d(getDateRange(5).toStr())

 /**
     * 获取日期范围
     * 需求：本周、本月、本季都不包含当天；如果范围内的开始时间等于或大于当天，则范围为空；
     * @param type Int 1:今日，2:本周，3:本月，4:本季
     * @return Array<String>
     */
    fun getDateRange(type: Int): Array<String> {
        val currentDayStart = TimeUtil.getCurrentDayStartTime()//今日开始时间
        var startDate: Date? = null//开始时间
        var endDateStr = ""//结束时间
        when (type) {
            1 -> {
                //今日
                startDate = currentDayStart
                endDateStr = DatetimeUtil.dateToLongStr(TimeUtil.getCurrentDayEndTime())!!//今日结束时间
            }
            2 -> {
                //本周
                startDate = TimeUtil.getCurrentWeekDayStartTime()
                if (currentDayStart <= startDate) {
                    LegoLog.d("本周（不含当天）")
                } else {
                    endDateStr = DatetimeUtil.yesterday() + " 23:59:59"//昨天结束
                }
            }
            3 -> {
                //本月
                startDate = TimeUtil.getCurrentMonthStartTime()
                if (currentDayStart <= startDate) {
                    LegoLog.d("本月（不含当天）")
                } else {
                    endDateStr = DatetimeUtil.yesterday() + " 23:59:59"//昨天结束
                }
            }
            4 -> {
                //本季
                startDate = TimeUtil.getCurrentQuarterStartTime()
                if (currentDayStart <= startDate) {
                    LegoLog.d("本季（不含当天）")
                } else {
                    endDateStr = DatetimeUtil.yesterday() + " 23:59:59"//昨天结束
                }
            }
        }
        return if (startDate != null && endDateStr.isNotEmpty()) {
            arrayOf(
                DatetimeUtil.dateToLongStr(startDate)!!,
                endDateStr
            )
        } else {
            arrayOf()
        }
    }

    private fun Array<String>.toStr(): String {
        val stringBuilder = StringBuilder()
        for (element in this) {
            println(element)
            stringBuilder.append("==>$element")
        }
        if (stringBuilder.toString().isNotEmpty()) {
            return stringBuilder.toString().substring(3)
        }
        return stringBuilder.toString()
    }
Android 自定义日期段选择控件功能(开始时间-结束时间)
08-19
主要介绍了Android 自定义日期段选择控件功能，开始时间-结束时间。本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
android 日历控件 可选开始时间结束时间
11-12
仿酒店入住时间和结束时间控件，可以选择一段时间，列出多个日期进行选择
android 日期选择 输入当前日期 ，查询所在本天所在周的起始日期与结束日期 （可跨年计算）
a136447572的专栏
05-18 1137
private void setTimeData(String type ,String str){ Log.i(&quot;info&quot;,CurrentWeak+&quot;&quot;); if (CurrentWeak.equals(&quot;0&quot;)){ CurrentWeak = &quot;7&quot;; } Str
Android根据开始日期和天（或时分秒）计算出结束日期
TieShiXinChangW的博客
08-01 245
SimpleDateFormat日期格式也可以是。
android日历获取周,从android中的周数和年份获取周开始和结束日期
weixin_35659005的博客
05-30 1078
您可以使用以下方法获取一周的第一个日期和结束日期void getStartEndOFWeek(int enterWeek, int enterYear){//enterWeek is week number//enterYear is yearCalendar calendar = Calendar.getInstance();calendar.clear();calendar.set(Calen...
Android 时间工具类（时间和日期的获取）
KWMax
09-23 846
public class DateUtil { public static final String DATE_FORMAT = "yyyy-MM-dd"; private static SimpleDateFormat sdf = new SimpleDateFormat("MM/dd"); private static SimpleDateFormat sdf2 =...
Android自定义时间控件选择开始时间到结束时间
热门推荐
行动者&&职业化
11-30 1万+
一丶效果图 二丶概述 大概是去年的这个时候说要做一个关于时间控件的总结，到这会才开始。在整理demo时，发现直接上代码也无法由浅入深讲解，眨眼就是11月30号了，踩着11月份的尾巴，先来一篇，后面再补充。 三丶看代码 （1）.需求分析 1.选择开始时间到结束时间 2.结束时间不能超过今天 3.开始时间不能超过结束时间 4.最早选择2017年1月1日 5.仿iOS（表示很无
android当前时间和结束时间天数,Android开始-结束时间选择控件
weixin_39746552的博客
05-29 778
控件说明：区间时间选择控件(仅支持时间的选择，日期默认为当天的系统日期)，可以选择一个开始时间与结束时间。可以设置时间间隔(以分钟为单位)我demo中设置的为30min。控件有开始结束时间的选择联动，目前为如果选择了开始时间的话结束时间为开始时间的后一个。废话不多说，效果图如下：运行效果图刚开始做的时候在网络找了下发现没有满足这个需求的控件，那就意味着需要自己动手啦(但是全部自己写的话代码量又会比...
Android中年月日时间获取
最新发布
weixin_65399034的博客
05-27 673
使用Calendar方法。
android 通过当前日期获取这个礼拜的开始时间和结束时间
shu_quan的博客
01-05 3480
/** * 获取这个礼拜的开始和结束时间 * @return */ public static Map<String, String> getDayWeek() { Map<String, String> weekMap = new HashMap<>(); final Calendar c = Calendar.getInstance(...
带有开始时间和结束时间的日期选择器
11-16
此DEMO为android studio项目，带有开始时间和结束时间的日期选择器，由于屏幕宽度有限，两个时间选择器为竖向串联模式。
android显示每一年所有日期的功能,Android获取一天前的时间、一个月前的时间、一年前的时间...
weixin_30474629的博客
05-25 939
这个比较简单，大家一眼也能看懂；程序中用到的时间的地方还是有的；下面直接给大家写代码：1.获取当前时间(相信这个大家再熟悉不过了吧)：SimpleDateFormatformat=newSimpleDateFormat("yyyy-MM-ddhh:mm:ss");Stringstr=format.format(newjava.util.Date());直接用控件加载或者写个类写在...
Android 昨日 本周内 本月内 本季度 本年度所取得范围
人若看透了自己，就不会小看了别人
09-27 528
由于项目中需要一个日期范围，因此写下了昨日 本周内 本月内 本季度 本年度所取得范围， 所有的一切是基于今天的日期。 //获取当天的时间 public static String getCurrentDate() { Calendar now = Calendar.getInstance(); int calendarMonth = now.get(Ca...
Android 获取当前的时间。年月日，时分秒，星期几， 日期转星期
meixi_android的博客
09-07 5973
SimpleDateFormat alldate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//获取日期时间 SimpleDateFormat year = new SimpleDateFormat("yyyy");//获取年份 SimpleDateFormat month = new SimpleDateFormat("MM")...
Android Calendar的运用
fhlxyzczq205301的专栏
03-27 501
 package com.iwode.common; import java.text.DateFormat; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util
android 计算所在周所在月的前后日期
m0_67598977的博客
04-23 477
@param dateL 日期 @return */ public static String formatDateTime(Date date, String formater) { SimpleDateFormat sdf = new SimpleDateFormat(formater); return sdf.format(date); } /** 将日期字符串转成日期 @param strDate 字符串日期 @return java..
获取月初和月末
裸睡的鱼
08-10 747
package com.chryl.test; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /** * 获取月初和月末 */ public class Test5 { public static void main(String[] args) throws Exception { getFirstAndLastDayOfMonth("2019-0.
Android 日期 Calendar 关于时间段的操作
ctg168的专栏
10-26 3891
根据一个传递过来的日期，得到指定类型的时间段：例如，传递过来一个日期，并指定一个类型(周、月份、季度、半年、年),返回一个Timespan，包含开始日期和结束日期.
安卓判断季度_2020年第1季度排名前5位的趋势安卓库
weixin_26727575的博客
09-22 121
安卓判断季度 机器人开发 (ANDROID DEVELOPMENT) We’re almost at the end of the first quarter of 2020 and lots is happening in the Android community. Android 11 Developer Preview is out, with a lot of new features ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

唐诺

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值