前语：时刻在软件开发中是一个常见的处理需求，包含获取当时时刻、时刻格局化、时刻比较、时刻差核算等操作。为了简化开发进程，能够编写一个时刻东西类来封装这些常用的时刻操作办法。

因东西类时刻类首要分格局化和时刻核算所以做一个拆分
DateUtil.java 首要功用格局化时刻东西类
TimeUtil.java 时刻东西处理类

最近写了一些文章浏览量和点赞保藏的比较多给我供给了很大的动力希望大家多给定见

时刻东西类

DateUtil 时刻东西类
功用介绍
首要办法和功用：
运用示例
示例代码
TimeUtil 时刻东西类
办法列表
运用示例
示例代码

DateUtil 时刻东西类

功用介绍

时刻东西类封装了以下常用功用：

获取当时时刻：获取系统当时的日期和时刻。
格局化时刻：将日期目标或时刻戳格局化为指定的时刻格局。
解析时刻：将字符串时刻解析为日期目标。
获取时刻差：核算两个日期之间的时刻差，包含天数、小时数、分钟数等。
判别时刻区间：判别指定时刻是否在给定的时刻区间内。
判别闰年：判别指定年份是否为闰年。
获取年份、月份、星期等：从日期目标中提取年份、月份、星期等信息。

首要办法和功用：

getCurrentDate(String pattern)：获取当时时刻的字符串表明。
formatToStr(long timestamp, String pattern)：将时刻戳格局化为指定格局的字符串。
formatToStr(Date date, String pattern)：将日期目标格局化为指定格局的字符串。
formatStringDate(String dateString, String format)：将字符串时刻依照指定格局进行格局化。
getCurrentTime()：获取当时时刻的日期目标。
formatTime(Date date, String pattern)：将日期目标格局化为指定格局的时刻字符串。
parseTime(String time, String pattern)：解析指定格局的时刻字符串为日期目标。
getTimeDifference(Date date1, Date date2, TimeUnit timeUnit)：核算两个日期之间的时刻差。
isInTimeRange(Date time, Date startTime, Date endTime)：判别指定时刻是否在给定时刻区间内。
isLeapYear(int year)：判别指定年份是否为闰年。
getYearFromDate(Date date)：获取指定日期目标的年份。
getMonthFromDate(Date date)：获取指定日期目标的月份。
getWeekdayFromDate(Date date)：获取指定日期目标的星期。

运用示例

下面是的一些常见用法示例：

// 获取当时时刻
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);
// 判别时刻区间
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();
    /**
     * 获取当时时刻的字符串表明
     *
     * @param pattern 时刻格局
     * @return 当时时刻的字符串表明
     */
    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 "";
    }
    /**
     * 获取当时时刻的日期目标
     *
     * @return 当时时刻的日期目标
     */
    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);
    }
    /**
     * 判别指定时刻是否在给定时刻区间内
     *
     * @param time      待判别的时刻
     * @param startTime 时刻区间的开端时刻
     * @param endTime   时刻区间的完毕时刻
     * @return 假如指定时刻在时刻区间内，回来 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 时刻东西类

时刻东西类供给了一系列用于处理时刻的办法，包含获取当时时刻、格局化时刻、判别时刻区间、核算时刻差等功用。该东西类根据最新的Android API，并供给了更加简练和易用的办法。

办法列表

getCurrentWeekOfMonth(): 获取当时时刻为本月的第几周。
getCurrentDayOfWeek(): 获取当时时刻为本周的第几天。
getCurrentDayOfWeekText(): 回来当时日期是星期几的文本表明。
isTimeInRange(time, startTime, endTime): 判别指定时刻是否在给定的时刻区间内。
isTimeInRange(time, startTime, endTime): 判别指定时刻是否在给定的时刻区间内。
isInTimeRange(currentTime, startTime, endTime): 判别指定时刻是否在给定的时刻区间内。
calculateDaysDifference(startDate, endDate): 核算两个日期之间相差的天数。
calculateTimeDifference(date): 回来友爱的时刻跨度表明。

运用示例

// 获取当时时刻为本月的第几周
int weekOfMonth = TimeUtil.getCurrentWeekOfMonth();
// 获取当时时刻为本周的第几天
int dayOfWeek = TimeUtil.getCurrentDayOfWeek();
// 回来当时日期是星期几的文本表明
String dayOfWeekText = TimeUtil.getCurrentDayOfWeekText();
// 判别指定时刻是否在时刻区间内
boolean isInRange = TimeUtil.isTimeInRange(time, startTime, endTime);
// 核算两个日期之间相差的天数
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 {
    /**
     * 获取当时时刻为本月的第几周
     *
     * @return 本月的第几周
     */
    public static int getCurrentWeekOfMonth() {
        Calendar calendar = Calendar.getInstance();
        int weekOfMonth = calendar.get(Calendar.WEEK_OF_MONTH);
        return weekOfMonth;
    }
    /**
     * 获取当时时刻为本周的第几天
     *
     * @return 本周的第几天（1代表周一，7代表周日）
     */
    public static int getCurrentDayOfWeek() {
        LocalDate currentDate = LocalDate.now();
        DayOfWeek dayOfWeek = currentDate.getDayOfWeek();
        int dayOfWeekValue = dayOfWeek.getValue();
        return dayOfWeekValue;
    }
    /**
     * 回来当时日期是星期几
     *
     * @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 "";
        }
    }
    /**
     * 判别指定时刻是否在时刻区间内
     *
     * @param time        待判别的时刻
     * @param startTime   时刻区间的开端时刻
     * @param endTime     时刻区间的完毕时刻
     * @return 假如指定时刻在时刻区间内，回来 true；不然回来 false
     */
    public static boolean isTimeInRange(Calendar time, Calendar startTime, Calendar endTime) {
        return time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0;
    }
    /**
     * 判别指定时刻是否在时刻区间内
     *
     * @param time        待判别的时刻
     * @param startTime   时刻区间的开端时刻
     * @param endTime     时刻区间的完毕时刻
     * @return 假如指定时刻在时刻区间内，回来 true；不然回来 false
     */
    public static boolean isTimeInRange(LocalDateTime time, LocalDateTime startTime, LocalDateTime endTime) {
        return time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0;
    }
    /**
     * 判别指定时刻是否在时刻区间内
     *
     * @param currentTime 待判别的时刻
     * @param startTime   时刻区间的开端时刻
     * @param endTime     时刻区间的完毕时刻
     * @return 假如指定时刻在时刻区间内，回来 true；不然回来 false
     */
    public static boolean isInTimeRange(Date currentTime, Date startTime, Date endTime) {
        long currentTimeMillis = currentTime.getTime();
        return currentTimeMillis >= startTime.getTime() && currentTimeMillis <= endTime.getTime();
    }
    /**
     * 求两个日期相差天数
     * @param startDate 开端时刻
     * @param endDate   完毕时刻
     * @return 相差天数
     */
    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();
        // 核算时刻差对应的单位
        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 "刚刚";
        }
    }
}

以上代码全部供给不在供给代码库房链接如有疑问请留言

假如以上的时刻东西类对您有所帮助，请不吝点赞和保藏。这个东西类旨在简化时刻处理的操作，供给了一系列方便易用的办法，帮助您更高效地处理时刻相关的业务逻辑。无论是获取当时时刻的某个特定值，仍是核算时刻差、判别时刻区间，亦或是格局化时刻，该东西类都能满意您的需求。运用这个东西类，您能够更轻松地处理时刻操作，进步开发效率。假如您觉得这个东西类有用，请给予您的支撑，以便将它保藏起来方便日后运用。感谢您的支撑和喜欢！

Android时间工具类

时刻东西类

DateUtil 时刻东西类

功用介绍

首要办法和功用：

运用示例

示例代码

TimeUtil 时刻东西类

办法列表

运用示例

示例代码

作者信息

推广

Android时间工具类

时刻东西类

DateUtil 时刻东西类

功用介绍

首要办法和功用：

运用示例

示例代码

TimeUtil 时刻东西类

办法列表

运用示例

示例代码

相关文章

组件库技术选型和开发环境搭建

史上最完美的Android沉浸式状态导航栏攻略

YAML简单使用

谈谈责任链，桥接，适配器，单例，命令设计模式

作者信息

推广