Android DateUtil時間工具類使用方法示例解析

更新時間：2023年07月19日 10:05:17 作者：沫小北

這篇文章主要為大家介紹了Android DateUtil時間工具類使用方法示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

引言

時間在軟件開發(fā)中是一個常見的處理需求，包括獲取當(dāng)前時間、時間格式化、時間比較、時間差計算等操作。為了簡化開發(fā)過程，可以編寫一個時間工具類來封裝這些常用的時間操作方法。

因工具類時間類主要分格式化和時間計算所以做一個拆分

DateUtil.java 主要功能格式化時間工具類

TimeUtil.java 時間工具處理類

DateUtil 時間工具類

功能介紹

時間工具類封裝了以下常用功能：

獲取當(dāng)前時間：獲取系統(tǒng)當(dāng)前的日期和時間。
格式化時間：將日期對象或時間戳格式化為指定的時間格式。
解析時間：將字符串時間解析為日期對象。
獲取時間差：計算兩個日期之間的時間差，包括天數(shù)、小時數(shù)、分鐘數(shù)等。
判斷時間區(qū)間：判斷指定時間是否在給定的時間區(qū)間內(nèi)。
判斷閏年：判斷指定年份是否為閏年。
獲取年份、月份、星期等：從日期對象中提取年份、月份、星期等信息。

主要方法和功能

getCurrentDate(String pattern)：獲取當(dāng)前時間的字符串表示。
formatToStr(long timestamp, String pattern)：將時間戳格式化為指定格式的字符串。
formatToStr(Date date, String pattern)：將日期對象格式化為指定格式的字符串。
formatStringDate(String dateString, String format)：將字符串時間按照指定格式進行格式化。
getCurrentTime()：獲取當(dāng)前時間的日期對象。
formatTime(Date date, String pattern)：將日期對象格式化為指定格式的時間字符串。
parseTime(String time, String pattern)：解析指定格式的時間字符串為日期對象。
getTimeDifference(Date date1, Date date2, TimeUnit timeUnit)：計算兩個日期之間的時間差。
isInTimeRange(Date time, Date startTime, Date endTime)：判斷指定時間是否在給定時間區(qū)間內(nèi)。
isLeapYear(int year)：判斷指定年份是否為閏年。
getYearFromDate(Date date)：獲取指定日期對象的年份。
getMonthFromDate(Date date)：獲取指定日期對象的月份。
getWeekdayFromDate(Date date)：獲取指定日期對象的星期。

常見用法示例

// 獲取當(dāng)前時間
Date currentTime = DateUtil.getCurrentTime();

// 格式化時間
String formattedTime = DateUtil.formatTime(currentTime, DateUtil.FORMAT_YYYY_MM_DD_HH_MM_SS);

// 解析時間
String timeString = "2023-07-14 12:00:00";
Date parsedTime = DateUtil.parseTime(timeString, DateUtil.FORMAT_YYYY_MM_DD_HH_MM_SS);

// 獲取時間差
Date startTime = new Date();
Date endTime = new Date(System.currentTimeMillis() + TimeUnit.HOURS.toMillis(2));
long timeDifference = DateUtil.getTimeDifference(startTime, endTime, TimeUnit.MINUTES);

// 判斷時間區(qū)間
Date time = new Date();
Date startTime = new Date(System.currentTimeMillis() - TimeUnit.DAYS.toMillis(1));
Date endTime = new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(1));
boolean isInTimeRange = DateUtil.isInTimeRange(time, startTime, endTime);

// 判斷閏年
int year = 2023;
boolean isLeapYear = DateUtil.isLeapYear(year);

// 獲取年份、月份、星期
int yearFromDate = DateUtil.getYearFromDate(currentTime);
int monthFromDate = DateUtil.getMonthFromDate(currentTime);
int weekdayFromDate = DateUtil.getWeekdayFromDate(currentTime);

示例代碼

以下是一個簡單的時間工具類的示例代碼：

import androidx.core.net.ParseException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;
/**
 * @author: xtxiaolu
 * @date: 2023/7/14
 * 描述: 主要功能格式化時間工具類
 */
public class DateUtil {
    // 日期格式年份，例如：2022，2023
    public static final String FORMAT_YYYY = "yyyy";
    // 其他格式常量...
    private static final TimeZone DEFAULT_TIMEZONE = TimeZone.getDefault();
    private static TimeZone DefaultTimeZone = TimeZone.getDefault();
    /**
     * 獲取當(dāng)前時間的字符串表示
     *
     * @param pattern 時間格式
     * @return 當(dāng)前時間的字符串表示
     */
    public static String getCurrentDate(String pattern) {
        return formatToStr(new Date(), pattern);
    }
    /**
     * 將時間戳格式化為指定格式的字符串
     *
     * @param timestamp 時間戳
     * @param pattern   時間格式
     * @return 格式化后的時間字符串
     */
    public static String formatToStr(long timestamp, String pattern) {
        return formatToStr(new Date(timestamp), pattern);
    }
    /**
     * 將日期對象格式化為指定格式的字符串
     *
     * @param date    日期對象
     * @param pattern 時間格式
     * @return 格式化后的時間字符串
     */
    public static String formatToStr(Date date, String pattern) {
        DateFormat dateFormat = getDateFormat(pattern);
        return dateFormat.format(date);
    }
    /**
     * 獲取指定格式的日期格式化對象
     *
     * @param pattern 時間格式
     * @return 日期格式化對象
     */
    private static DateFormat getDateFormat(String pattern) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        dateFormat.setTimeZone(DEFAULT_TIMEZONE);
        return dateFormat;
    }
    /**
     * 格式化字符串時間為指定格式
     *
     * @param dateString 字符串時間
     * @param format     格式
     * @return 格式化后的時間字符串
     */
    public static String formatStringDate(String dateString, String format) {
        SimpleDateFormat inputFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat outputFormat = new SimpleDateFormat(format);
        try {
            Date date = inputFormat.parse(dateString);
            return outputFormat.format(date);
        } catch (ParseException | java.text.ParseException e) {
            e.printStackTrace();
        }
        return "";
    }
    /**
     * 獲取當(dāng)前時間的日期對象
     *
     * @return 當(dāng)前時間的日期對象
     */
    public static Date getCurrentTime() {
        return new Date();
    }
    /**
     * 將日期對象格式化為指定格式的時間字符串
     *
     * @param date    日期對象
     * @param pattern 時間格式
     * @return 格式化后的時間字符串
     */
    public static String formatTime(Date date, String pattern) {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.format(date);
    }
    /**
     * 解析指定格式的時間字符串為日期對象
     *
     * @param time    時間字符串
     * @param pattern 時間格式
     * @return 解析后的日期對象
     * @throws ParseException 解析異常
     */
    public static Date parseTime(String time, String pattern) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        try {
            return sdf.parse(time);
        } catch (java.text.ParseException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 計算兩個日期之間的時間差，返回指定時間單位的差值
     *
     * @param date1     第一個日期對象
     * @param date2     第二個日期對象
     * @param timeUnit  時間單位
     * @return 時間差的差值
     */
    public static long getTimeDifference(Date date1, Date date2, TimeUnit timeUnit) {
        long difference = date2.getTime() - date1.getTime();
        return timeUnit.convert(difference, TimeUnit.MILLISECONDS);
    }
    /**
     * 判斷指定時間是否在給定時間區(qū)間內(nèi)
     *
     * @param time      待判斷的時間
     * @param startTime 時間區(qū)間的開始時間
     * @param endTime   時間區(qū)間的結(jié)束時間
     * @return 如果指定時間在時間區(qū)間內(nèi)，返回 true；否則返回 false
     */
    public static boolean isInTimeRange(Date time, Date startTime, Date endTime) {
        return time.after(startTime) && time.before(endTime);
    }
    /**
     * 判斷指定年份是否為閏年
     *
     * @param year 年份
     * @return 如果是閏年，返回 true；否則返回 false
     */
    public static boolean isLeapYear(int year) {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }
    /**
     * 獲取指定日期對象的年份
     *
     * @param date 日期對象
     * @return 年份
     */
    public static int getYearFromDate(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }
    /**
     * 獲取指定日期對象的月份
     *
     * @param date 日期對象
     * @return 月份
     */
    public static int getMonthFromDate(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MONTH) + 1;
    }
    /**
     * 獲取指定日期對象的星期
     *
     * @param date 日期對象
     * @return 星期，1 表示星期一，2 表示星期二，依次類推
     */
    public static int getWeekdayFromDate(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.DAY_OF_WEEK);
    }
}

TimeUtil 時間工具類

時間工具類提供了一系列用于處理時間的方法，包括獲取當(dāng)前時間、格式化時間、判斷時間區(qū)間、計算時間差等功能。該工具類基于最新的Android API，并提供了更加簡潔和易用的方法。

方法列表

getCurrentWeekOfMonth(): 獲取當(dāng)前時間為本月的第幾周。
getCurrentDayOfWeek(): 獲取當(dāng)前時間為本周的第幾天。
getCurrentDayOfWeekText(): 返回當(dāng)前日期是星期幾的文本表示。
isTimeInRange(time, startTime, endTime): 判斷指定時間是否在給定的時間區(qū)間內(nèi)。
isTimeInRange(time, startTime, endTime): 判斷指定時間是否在給定的時間區(qū)間內(nèi)。
isInTimeRange(currentTime, startTime, endTime): 判斷指定時間是否在給定的時間區(qū)間內(nèi)。
calculateDaysDifference(startDate, endDate): 計算兩個日期之間相差的天數(shù)。
calculateTimeDifference(date): 返回友好的時間跨度表示。

方法示例

// 獲取當(dāng)前時間為本月的第幾周
int weekOfMonth = TimeUtil.getCurrentWeekOfMonth();
// 獲取當(dāng)前時間為本周的第幾天
int dayOfWeek = TimeUtil.getCurrentDayOfWeek();
// 返回當(dāng)前日期是星期幾的文本表示
String dayOfWeekText = TimeUtil.getCurrentDayOfWeekText();
// 判斷指定時間是否在時間區(qū)間內(nèi)
boolean isInRange = TimeUtil.isTimeInRange(time, startTime, endTime);
// 計算兩個日期之間相差的天數(shù)
long daysDifference = TimeUtil.calculateDaysDifference(startDate, endDate);
// 返回友好的時間跨度表示
String timeDifference = TimeUtil.calculateTimeDifference(date);

示例代碼

import java.text.DateFormatSymbols;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.concurrent.TimeUnit;
/**
 * @author: xtxiaolu
 * @date: 2023/7/14
 * 描述:時間工具處理類
 */
public class TimeUtil {
    /**
     * 獲取當(dāng)前時間為本月的第幾周
     *
     * @return 本月的第幾周
     */
    public static int getCurrentWeekOfMonth() {
        Calendar calendar = Calendar.getInstance();
        int weekOfMonth = calendar.get(Calendar.WEEK_OF_MONTH);
        return weekOfMonth;
    }
    /**
     * 獲取當(dāng)前時間為本周的第幾天
     *
     * @return 本周的第幾天（1代表周一，7代表周日）
     */
    public static int getCurrentDayOfWeek() {
        LocalDate currentDate = LocalDate.now();
        DayOfWeek dayOfWeek = currentDate.getDayOfWeek();
        int dayOfWeekValue = dayOfWeek.getValue();
        return dayOfWeekValue;
    }
    /**
     * 返回當(dāng)前日期是星期幾
     *
     * @return 例如：星期日、星期一、星期六等等。
     */
    public static String getCurrentDayOfWeekText() {
        Calendar calendar = Calendar.getInstance();
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        // 獲取星期幾文本
        DateFormatSymbols symbols = new DateFormatSymbols(Locale.getDefault());
        String[] dayOfWeekTexts = symbols.getWeekdays();
        if (dayOfWeek >= Calendar.SUNDAY && dayOfWeek <= Calendar.SATURDAY) {
            return dayOfWeekTexts[dayOfWeek];
        } else {
            return "";
        }
    }
    /**
     * 判斷指定時間是否在時間區(qū)間內(nèi)
     *
     * @param time        待判斷的時間
     * @param startTime   時間區(qū)間的開始時間
     * @param endTime     時間區(qū)間的結(jié)束時間
     * @return 如果指定時間在時間區(qū)間內(nèi)，返回 true；否則返回 false
     */
    public static boolean isTimeInRange(Calendar time, Calendar startTime, Calendar endTime) {
        return time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0;
    }
    /**
     * 判斷指定時間是否在時間區(qū)間內(nèi)
     *
     * @param time        待判斷的時間
     * @param startTime   時間區(qū)間的開始時間
     * @param endTime     時間區(qū)間的結(jié)束時間
     * @return 如果指定時間在時間區(qū)間內(nèi)，返回 true；否則返回 false
     */
    public static boolean isTimeInRange(LocalDateTime time, LocalDateTime startTime, LocalDateTime endTime) {
        return time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0;
    }
    /**
     * 判斷指定時間是否在時間區(qū)間內(nèi)
     *
     * @param currentTime 待判斷的時間
     * @param startTime   時間區(qū)間的開始時間
     * @param endTime     時間區(qū)間的結(jié)束時間
     * @return 如果指定時間在時間區(qū)間內(nèi)，返回 true；否則返回 false
     */
    public static boolean isInTimeRange(Date currentTime, Date startTime, Date endTime) {
        long currentTimeMillis = currentTime.getTime();
        return currentTimeMillis >= startTime.getTime() && currentTimeMillis <= endTime.getTime();
    }
    /**
     * 求兩個日期相差天數(shù)
     * @param startDate 開始時間
     * @param endDate   結(jié)束時間
     * @return 相差天數(shù)
     */
    public static long calculateDaysDifference(Date startDate, Date endDate) {
        long differenceMillis = endDate.getTime() - startDate.getTime();
        long differenceDays = TimeUnit.MILLISECONDS.toDays(differenceMillis);
        return differenceDays;
    }
    /**
     * 返回友好時間跨度
     *
     * @param date 需要格式化的時間
     *
     * @return the fit time span
     *         return 小于1分鐘，返回"剛剛"
     *         return 小于1小時但大于0分鐘，返回"X分鐘前"
     *         return 小于1天但大于0小時，返回"X小時前"
     *         return 昨天，返回"昨天"
     *         return 大于1天，返回"X天前"
     */
    public static String calculateTimeDifference(Date date) {
        long currentTime = System.currentTimeMillis();
        long timeDifference = currentTime - date.getTime();
        // 計算時間差對應(yīng)的單位
        long seconds = timeDifference / 1000;
        long minutes = seconds / 60;
        long hours = minutes / 60;
        long days = hours / 24;
        if (days > 1) {
            // 大于1天，返回"X天前"
            return days + "天前";
        } else if (days == 1) {
            // 昨天，返回"昨天"
            return "昨天";
        } else if (hours > 0) {
            // 小于1天但大于0小時，返回"X小時前"
            return hours + "小時前";
        } else if (minutes > 0) {
            // 小于1小時但大于0分鐘，返回"X分鐘前"
            return minutes + "分鐘前";
        } else {
            // 小于1分鐘，返回"剛剛"
            return "剛剛";
        }
    }
}

如果以上的時間工具類對您有所幫助，請不吝點贊和收藏。這個工具類旨在簡化時間處理的操作，提供了一系列方便易用的方法，幫助您更高效地處理時間相關(guān)的業(yè)務(wù)邏輯。

無論是獲取當(dāng)前時間的某個特定值，還是計算時間差、判斷時間區(qū)間，亦或是格式化時間，該工具類都能滿足您的需求。

使用這個工具類，您可以更輕松地處理時間操作，提高開發(fā)效率。如果您覺得這個工具類有用，請給予您的支持，以便將它收藏起來方便日后使用。

更多關(guān)于Android DateUtil時間工具類的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: