java中的日期处理类总结
java中的日期处理类总结：Date/Calendar/GregorianCalendar/DateFormat/SimpleDateFormat类今天花了好大一点时间把java的日期类做了一下整理，哈1、Date类（该类现在很少用了）lDate类对象的创建：n创建一个当前时间//默认是创建一个代表系统当前日期的Date对象Date d = new Date();n创建一个我们指定的时间的Date对象：下面是使用带参数的构造方法，可以构造指定日期的Date类对象，Date类中年份的参数应该是实际需要代表的年份减去1900，实际需要代表的月份减去1以后的值。
//创建一个代表2009年6月12号的Date对象Date d1 = new Date(2009-1900, 6-1, 12);（注意参数的设置啊！）l正确获得一个date对象所包含的信息如：Date d2 =new Date(2009-1900, 6-1, 12);//获得年份（注意年份要加上1900，这样才是日期对象d2所代表的年份）int year = d2."getYear() + 1900;//获得月份（注意月份要加1，这样才是日期对象d2所代表的月份）int month = d2."getMonth() + 1;//获得日期int date = d2."getDate();//获得小时int hour = d2."getHours();//获得分钟int minute = d2."getMinutes();//获得秒int second = d2."getSeconds();//获得星期（注意：0代表星期日、1代表星期1、"2代表星期2，其他的一次类推了）int day = d2."getDay();运行结果：年份：2009月份：6日期：12小时：0//不设置默认是0分钟：0//不设置默认是0秒：0//不设置默认是0星期：5//09-6-12今天就是星期5，又是一个星期天哦2、Calendar类Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些lCalendar类对象的创建Calendar类是一个抽象类，在实际使用时实现特定的子类的对象。
由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。
n创建一个代表系统当前日期的Calendar对象Calendar c = Calendar.getInstance();//默认是当前日期n创建一个指定日期的Calendar对象使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的____年__月__日参数来完成。
//创建一个代表2009年6月12日的Calendar对象Calendar c1 = Calendar.getInstance();c1."set(2009, 6 - 1, 12);lCalendar类对象字段类型Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想Calendar.YEAR——年份Calendar.MONTH——月份Calendar.DATE——日期Calendar.DAY_OF_MONTH——日期，和上面的字段意义完全相同Calendar.HOUR——12小时制的小时Calendar.HOUR_OF_DAY——24小时制的小时Calendar.MINUTE——分钟Calendar.SECOND——秒Calendar.DAY_OF_WEEK——星期几lCalendar类对象信息的设置与获得nCalendar类对象信息的设置uSet设置如：Calendar c1 = Calendar.getInstance();调用：public final void set(int year,int month,int date)c1."set(2009, 6 - 1, 12);//把Calendar对象c1的____年__月__日分别设这为：2009、"6、12利用字段类型设置如果只设定某个字段，例如日期的值，则可以使用如下set方法：调用：public void set(int field,int value)//把c1对象代表的日期设置为10号，其它所有的数值会被重新计算c1."set(Calendar.DATE,10);//把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算c1."set(Calendar.YEAR,2008);其他字段属性set的意义以此类推uAdd设置Calendar c1 = Calendar.getInstance();//把c1对象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的数值会被重新计算c1."add(Calendar.DATE, 10);//把c1对象的日期加上10，也就是c1所表的日期的10天前的日期，其它所有的数值会被重新计算c1."add(Calendar.DATE, -10);其他字段属性的add的意义以此类推nCalendar类对象信息的获得Calendar c1 = Calendar.getInstance();//获得年份int year = c1."get(Calendar.YEAR);//获得月份int month = c1."get(Calendar.MONTH) + 1;//获得日期int date = c1."get(Calendar.DATE);//获得小时int hour = c1."get(Calendar.HOUR_OF_DAY);//获得分钟int minute = c1."get(Calendar.MINUTE);//获得秒int second = c1."get(Calendar.SECOND);//获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、"3代表星期二，以此类推）int day = c1."get(Calendar.DAY_OF_WEEK);3、GregorianCalendar类GregorianCalendar是Calendar的一个具体子类，提供了世界上大多数国家使用的标准日历系统。
GregorianCalendar类对象的创建GregorianCalendar有自己的构造方法，而其父类Calendar没有公开的构造方法哦。
GregorianCalendar()在具有默认语言环境的默认时区内使用当前时间构造一个默认的GregorianCalendar。
GregorianCalendar(int year, int month, int dayOfMonth)在具有默认语言环境的默认时区内构造一个带有给定日期设置的GregorianCalendar。
GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute)为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的GregorianCalendar。
GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second)为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的GregorianCalendar。
创建一个代表当前日期的GregorianCalendar对象GregorianCalendar gc = new GregorianCalendar();//创建一个代表2009年6月12日的GregorianCalendar对象(注意参数设置哦，与其父类是一样的哦，月份要减去1)GregorianCalendar gc = new GregorianCalendar(2009,6-1,12);字段属性什么的都是随其父Calendar了，呵另外：GregorianCalendar有下面一个方法：isLeapYear(int year)确定给定的年份是否为闰年4、DateFormat类DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。
日期/时间格式化子类（如SimpleDateFormat）允许进行格式化（也就是日期->文本）、分析（文本->日期）和标准化。
将日期表示为Date对象，或者表示为从GMT（格林尼治标准时间）1970年，1月1日00:00:00这一刻开始的毫秒数。
5、SimpleDateFormat类publicclassSimpleDateFormatextendsDateFormatSimpleDateFormat是一个以与语言环境相关的方式来格式化和分析日期的具体类。
它允许进行格式化（日期->文本）、分析（文本->日期）和规范化。
所以本类可以实现：String到Date到String的互转，如下：SimpleDateFormat对象最常用的就是一下两招了：//注意构造函数中是SimpleDateFormat类解析日期的模式，大小写代表的意义完全不一样哦SimpleDateFormat df = new SimpleDateFormat("yy-MM-dd hh:mm:ss");//日期到字符串的转换String today = df.format(new Date());//字符串到日期的转换Date date = df.parse("2009-06-12 02:06:37"); System.out.println(df.format(new Date()));6、日期类对象之间的互转lDate类对象与long型时间的互转//将Date类的对象转换为long型时间Date d= new Date();//使用对象的getTime（）方法完成long dLong = d.getTime();//将long型时间转换为Date类的对象long time = 32190L;//使用Date的构造方法完成Date d2 = new Date(time);lCalendar对象和long型时间之间的互转//将Calendar对象转换为相对时间Calendar c = Calendar.getInstance();long t1 = c.getTimeInMillis();//将相对时间转换为Calendar对象Calendar c1 = Calendar.getInstance();long t = 71098L;c1."setTimeInMillis(t1);lCalendar对象和Date对象之间的互转//将Calendar对象转换为相对时间Calendar c = Calendar.getInstance();Date d = c.getTime();//将相对时间转换为Calendar对象Calendar c1 = Calendar.getInstance();Date d1 = new Date();//通过setTime（）方法后，日历c1所表示的日期就d1的日期c1."setTime(d1);7、Ok，利用以上各个类的功能，我们可以很简单的实现一些时间计算的功能哦，呵呵，下面看几个方法：l判断是否是闰年/***给定一个年份判断该年份是否为闰年create date:2009-6-10 author:Administrator** @param year* @return*/public static boolean isLeapYear(int year) {GregorianCalendar calendar = new GregorianCalendar();return calendar.isLeapYear(year);}l获取当前日期的字符串表示形式/***利用SimpleDateFormat获取当前日期的字符串表示形式格式：2009-55-05* * create date:2009-6-5 author:Administrator** @return*/public static String getCurrentDate() {//注意SimpleDateFormat("yy-MM-dd")的参数间隔符号可以随意设置的，如：// yy年MM月dd日返回格式：2009年06月09日// yy-MM-dd返回格式：2009-06-09// SimpleDateFormat dateFormat = new SimpleDateFormat(// "yy-MM-dd HH:mm:ss");SimpleDateFormat dateFormat = new SimpleDateFormat("yy-MM-dd");return dateFormat.format(System.currentTimeMillis());}l给出任意一个____年__月__日得到该天是星期几/***给出任意一个____年__月__日得到该天是星期几create date:2009-6-10 author:Administrator** @param date*参数格式2009-6-10*返回值：0代表星期日，1代表星期1，2代表星期2，以此类推*/public static int getWeek(String date) {//注意参数的大小写格式SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");Calendar c = Calendar.getInstance();try {Date d = dateFormat.parse(date);c.setTime(d);} catch (ParseException e) {}return c.get(Calendar.DAY_OF_WEEK)-1;}l获得今天n天以后或者n天以前是那一天/***获得距离今天n天的那一天的日期create date:2009-6-11 author:Administrator** @param day* @return*/public static String getDistanceDay(int day) {Calendar calen = Calendar.getInstance();calen.add(Calendar.DAY_OF_MONTH, day);Date date = calen.getTime();//这里也个用SimpleDateFormat的format（）进行格式化，然后以字符串形式返回格式化后的dateSimpleDateFormat dateFormat = new SimpleDateFormat("yy-MM-dd");return dateFormat.format(date);}l获得距离指定日期n天的那一天的日期/***获得距离指定日期n天的那一天的日期create date:2009-6-11 author:Administrator** @param date*格式：2009-6-11* @param day* @return*/public static String getDistanceDay(String date, int day) {SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");Date d;Calendar c =Calendar.getInstance();try {d = dateFormat.parse(date);c.setTime(d);c.add(Calendar.DATE, day);} catch (ParseException e) {// TODO Auto-generated catch blocke.printStackTrace();}return dateFormat.format(c.getTime());}/** *获得给定两个日期相差度天数* create date:2009-6-23 author:Administrator** @param date1*参数格式:2009-06-21* @param date2*/public static long getGapDays(String date1, String date2) { String[] d1 = date1."split("-");String[] d2 = date2."split("-");Calendar c = Calendar.getInstance();c.set(Integer.parseInt(d1[0]), Integer.parseInt(d1[1]), Integer.parseInt(d1[2]), 0, 0, 0);long l1 = c.getTimeInMillis();c.set(Integer.parseInt(d2[0]), Integer.parseInt(d2[1]), Integer.parseInt(d2[2]), 0, 0, 0);long l2 = c.getTimeInMillis();return (Math.abs(l1 - l2) / (24 * 60 * 60 * 1000));}本文来自CSDN博客，转载请http:."aspx标明处出：。
Java时间日期处理技巧：日期格式化和时区设置
Java时间日期处理技巧：日期格式化和时区设置在Java编程中，日期和时间处理是非常常见的任务。
无论是在开发Web应用程序、处理数据还是进行系统日志记录，都需要对日期和时间进行操作。
本文将介绍一些Java中常用的日期格式化和时区设置的技巧，帮助开发者更好地处理日期和时间。
1. 日期格式化日期格式化是将日期对象转换为特定格式的字符串表示。
Java提供了SimpleDateFormat类来实现日期格式化。
以下是一个简单的例子：```javaimport java.text.SimpleDateFormat;import java.util.Date;public class DateFormatExample {public static void main(String[] args) {Date date = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String formattedDate = sdf.format(date);System.out.println("Formatted Date: " + formattedDate);}}```在上面的例子中，我们使用了"yyyy-MM-dd HH:mm:ss"作为日期格式化的模式，它将日期格式化为"年-月-日时:分:秒"的形式。
Java的日期格式化模式有很多选项，可以根据需求进行调整。
例如，"yyyy-MM-dd"表示"年-月-日"，"HH:mm:ss"表示"时:分:秒"，"EEE"表示星期几等等。
更多的格式化选项可以参考Java官方文档。
2. 时区设置时区是指地球上划分的不同区域，每个时区都有自己的标准时间。
JAVA时间日期处理类，主要用来遍历两个日期之间的每一天
JAVA时间⽇期处理类，主要⽤来遍历两个⽇期之间的每⼀天import java.text.DecimalFormat;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Date;import java.util.List;/*** 遍历两个时间段中间的每⼀天* @author 天涯⿁域* 2019.01.30*/public class AccountDate {private static transient int gregorianCutoverYear = 1582;/** 闰年中每⽉天数 */private static final int[] DAYS_P_MONTH_LY= {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};/** ⾮闰年中每⽉天数 */private static final int[] DAYS_P_MONTH_CY= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};/** 代表数组⾥的年、⽉、⽇ */private static final int Y = 0, M = 1, D = 2;/*** 将代表⽇期的字符串分割为代表年⽉⽇的整形数组* @param date* @return*/public static int[] splitYMD(String date){date = date.replace("-", "");int[] ymd = {0, 0, 0};ymd[Y] = Integer.parseInt(date.substring(0, 4));ymd[M] = Integer.parseInt(date.substring(4, 6));ymd[D] = Integer.parseInt(date.substring(6, 8));return ymd;}/*** 检查传⼊的参数代表的年份是否为闰年* @param year* @return*/public static boolean isLeapYear(int year) {return year >= gregorianCutoverYear ?((year%4 == 0) && ((year%100 != 0) || (year%400 == 0))) : (year%4 == 0);}/*** ⽇期加1天* @param year* @param month* @param day* @return*/private static int[] addOneDay(int year, int month, int day){if(isLeapYear( year )){day++;if( day > DAYS_P_MONTH_LY[month -1 ] ){month++;if(month > 12){year++;month = 1;}day = 1;}}else{day++;if( day > DAYS_P_MONTH_CY[month -1 ] ){month++;if(month > 12){year++;month = 1;}day = 1;}}int[] ymd = {year, month, day};return ymd;}/*** 将不⾜两位的⽉份或⽇期补⾜为两位* @param decimal* @return*/public static String formatMonthDay(int decimal){DecimalFormat df = new DecimalFormat("00");return df.format( decimal );}/*** 将不⾜四位的年份补⾜为四位* @param decimal* @return*/public static String formatYear(int decimal){DecimalFormat df = new DecimalFormat("0000");return df.format( decimal );}/*** 计算两个⽇期之间相隔的天数* @param begin* @param end* @return* @throws ParseException*/public static long countDay(String begin,String end){ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); Date beginDate , endDate;long day = 0;try {beginDate= format.parse(begin);endDate= format.parse(end);day=(endDate.getTime()-beginDate.getTime())/(24*60*60*1000);} catch (ParseException e) {e.printStackTrace();}return day;}/*** 以循环的⽅式计算⽇期* @param beginDate endDate* @param days* @return*/public static List<String> getEveryday(String beginDate , String endDate){ long days = countDay(beginDate, endDate);int[] ymd = splitYMD( beginDate );List<String> everyDays = new ArrayList<String>();everyDays.add(beginDate);for(int i = 0; i < days; i++){ymd = addOneDay(ymd[Y], ymd[M], ymd[D]);everyDays.add(formatYear(ymd[Y])+"-"+formatMonthDay(ymd[M])+"-"+formatMonthDay(ymd[D])); }return everyDays;}public static void main(String[] args) {List<String> list = AccountDate.getEveryday("2008-08-29", "2008-09-02");for (String result : list) {System.out.println(result);}}}。
datefomattar写法
datefomattar写法日期是我们在日常生活中经常使用的一种时间格式。
在计算机程序中，日期格式的处理和显示被认为是非常重要的一部分。
日期格式的正确处理和格式化可以为程序开发者和用户带来很多便利。
在Java 语言中，日期的格式处理主要使用了SimpleDateFormat类，并通过对Date类或Calendar类进行格式化来使用。
一、SimpleDateFormat类SimpleDateFormat是用来格式化和解析日期的类，它允许按照指定的日期格式来创建一个表示日期的字符串。
我们可以先来看一下SimpleDateFormat类的基本用法：1. 创建SimpleDateFormat对象SimpleDateFormat的构造方法包含两个参数，第一个参数用于指定日期格式字符串，第二个参数是可选的Locale对象，表示使用哪种地区的格式化方式。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日", Locale.getDefault());2. 格式化日期调用SimpleDateFormat的format方法，可以把一个Date对象或Calendar对象按照指定的格式输出字符串。
String dateString = sdf.format(new Date());3. 解析日期调用SimpleDateFormat的parse方法，可以把一个特定格式的字符串解析为Date对象，但要注意的是，它可能会抛出ParseException异常。
Date date = sdf.parse("2022-08-22");二、日期格式字符串在SimpleDateFormat中，日期的格式是由日期格式字符串来定义的。
JAVA处理日期时间常用方法
JA V A处理日期时间常用方法:java.util.CalendarCalendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期提供了一些方法。
瞬间可用毫秒值来表示,它是距历元（即格林威治标准时间1970 年 1 月1 日的00:00:00。
000,格里高利历的偏移量.例：Calendar cal = Calendar。
getInstance(；//使用默认时区和语言环境获得一个日历。
cal。
add(Calendar.DAY_OF_MONTH， -1;//取当前日期的前一天。
cal。
add（Calendar。
DAY_OF_MONTH, +1;//取当前日期的后一天。
//通过格式化输出日期java.text.SimpleDateFormat format = new java.text。
SimpleDateFormat(”yyyy-MM—dd"；System。
out.println（"Today is:”+format。
format(Calendar.getInstance(.getTime （；System。
out.println（"yesterday is："+format.format（cal.getTime（；得到2007—12-25日期: Calendar calendar = new GregorianCalendar（2007，11， 25,0，0,0；Date date = calendar.getTime(;System。
out.println("2007 Christmasis：”+format.format（date；//java月份是从0—11，月份设置时要减1。
//GregorianCalendar构造方法参数依次为：年,月—1,日，时，分，秒。
java calendar用法
java calendar用法Java Calendar用法Java Calendar是Java中的一个日期和时间处理类，它提供了一系列处理日期和时间的方法。
在Java中，Calendar类是一个抽象类，不能直接实例化，需要通过getInstance()方法获取一个Calendar对象。
一、获取Calendar对象Calendar calendar = Calendar.getInstance();二、获取日期和时间信息1. 获取年份信息int year = calendar.get(Calendar.YEAR);2. 获取月份信息int month = calendar.get(Calendar.MONTH) + 1;注意：月份从0开始计数，所以需要加1。
3. 获取日期信息int day = calendar.get(Calendar.DAY_OF_MONTH);4. 获取星期几信息int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK); 注意：星期天为1，星期六为7。
5. 获取小时信息int hour = calendar.get(Calendar.HOUR_OF_DAY);6. 获取分钟信息int minute = calendar.get(Calendar.MINUTE);7. 获取秒钟信息int second = calendar.get(Calendar.SECOND);8. 获取毫秒信息int millisecond = calendar.get(LISECOND);三、设置日期和时间信息1. 设置年份信息calendar.set(Calendar.YEAR, 2022);2. 设置月份信息（月份从0开始计数）calendar.set(Calendar.MONTH, 0);3. 设置日期信息calendar.set(Calendar.DAY_OF_MONTH, 1);4. 设置小时信息（24小时制）calendar.set(Calendar.HOUR_OF_DAY, 12);5. 设置分钟信息calendar.set(Calendar.MINUTE, 30);6. 设置秒钟信息calendar.set(Calendar.SECOND, 0);7. 设置毫秒信息calendar.set(LISECOND, 0);四、日期和时间的计算1. 年份的加减calendar.add(Calendar.YEAR, 1); // 加一年calendar.add(Calendar.YEAR, -1); // 减一年2. 月份的加减calendar.add(Calendar.MONTH, 1); // 加一个月calendar.add(Calendar.MONTH, -1); // 减一个月3. 日期的加减calendar.add(Calendar.DAY_OF_MONTH, 1); // 加一天calendar.add(Calendar.DAY_OF_MONTH, -1); // 减一天4. 小时的加减calendar.add(Calendar.HOUR_OF_DAY, 1); // 加一小时calendar.add(Calendar.HOUR_OF_DAY, -1); // 减一小时5. 分钟的加减calendar.add(Calendar.MINUTE, 10); // 加十分钟calendar.add(Calendar.MINUTE, -10); // 减十分钟6. 秒钟的加减calendar.add(Calendar.SECOND, 30); // 加三十秒钟calendar.add(Calendar.SECOND, -30); // 减三十秒钟7. 毫秒的加减calendar.add(LISECOND, 500); // 加五百毫秒calendar.add(LISECOND, -500); // 减五百毫秒五、日期和时间格式化输出可以使用SimpleDateFormat类将日期和时间格式化输出。
java处理日期的工具类DateUtil
java处理⽇期的⼯具类DateUtil java中处理⽇期的⼯具类DateUtil，供⼤家参考，具体内容如下package com.leo.demo.othertest;import org.slf4j.LoggerFactory;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.GregorianCalendar;import java.util.logging.Logger;/*** 时间⼯具类*/public final class DateUtil {private static Logger logger = (Logger) LoggerFactory.getLogger(DateUtil.class);/*** ⽇期格式*/public interface DATE_PATTERN {String HHMMSS = "HHmmss";String HH_MM_SS = "HH:mm:ss";String HH_MM = "HH:mm";String YYYY = "yyyy";String YYYYMMDD = "yyyyMMdd";String YYYYMM = "yyyyMM";String YYYY_MM_DD = "yyyy-MM-dd";String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";}/*** 获取当前时间** @return Timestamp对象*/public static Timestamp getCurrontTime() {Timestamp sqlTimestamp = new Timestamp(new Date().getTime());return sqlTimestamp;}/*** 将Date类型转换成String类型** @param date Date对象* @return 形如:"yyyy-MM-dd HH:mm:ss"*/public static String date2String(Date date) {return date2String(date, DATE_PATTERN.YYYY_MM_DD_HH_MM_SS);}/*** 将Date按格式转化成String** @param date Date对象* @param pattern ⽇期类型* @return String*/public static String date2String(Date date, String pattern) {if (date == null || pattern == null) {return null;}return new SimpleDateFormat(pattern).format(date);}/*** 将String类型转换成Date类型** @param date Date对象* @return*/public static Date string2Date(String date) {SimpleDateFormat format = new SimpleDateFormat(DATE_PATTERN.YYYY_MM_DD_HH_MM_SS); try {return format.parse(date);} catch (ParseException e) {return null;}}/*** 获取某⽇期N天后的⽇期** @param datestr* @param day* @return*/public static Date getBeforeAfterDate(String datestr, int day) {SimpleDateFormat df = new SimpleDateFormat(DATE_PATTERN.YYYY_MM_DD_HH_MM_SS);java.sql.Date olddate = null;try {df.setLenient(false);olddate = new java.sql.Date(df.parse(datestr).getTime());} catch (ParseException e) {throw new RuntimeException("⽇期转换错误");}Calendar cal = new GregorianCalendar();cal.setTime(olddate);int Year = cal.get(Calendar.YEAR);int Month = cal.get(Calendar.MONTH);int Day = cal.get(Calendar.DAY_OF_MONTH);int NewDay = Day + day;cal.set(Calendar.YEAR, Year);cal.set(Calendar.MONTH, Month);cal.set(Calendar.DAY_OF_MONTH, NewDay);return new Date(cal.getTimeInMillis());}/*** @return* @Description: 获取当前⽇期的前⼀天* @ReturnType String* @author: liyl* @Created 2015年11⽉13⽇下午5:11:14*/public static Date currentBeforeDay() {Calendar calendar = Calendar.getInstance();calendar.setTime(new Date());calendar.add(Calendar.DAY_OF_MONTH, -1);return calendar.getTime();}/*** @return* @Description: 获取当前⽇期的后⼀天* @ReturnType Date* @author: liyl* @Created 2015年11⽉13⽇下午5:14:54*/public static Date currentNextDay() {Calendar calendar = Calendar.getInstance();calendar.setTime(new Date());calendar.add(Calendar.DAY_OF_MONTH, 1);return calendar.getTime();}/*** 获取指定⽇期星期⼏(int)** @param dt* @return*/public static int getWeekOfInt(Date dt) {int[] weekDays = {7, 1, 2, 3, 4, 5, 6};Calendar cal = Calendar.getInstance();cal.setTime(dt);int w = cal.get(Calendar.DAY_OF_WEEK) - 1;if (w < 0) {w = 0;}return weekDays[w];}/*** 获取指定⽇期星期⼏** @param dt* @return*/public static String getWeekOfDate(Date dt) {String[] weekDays = {"星期⽇", "星期⼀", "星期⼆", "星期三", "星期四", "星期五", "星期六"}; Calendar cal = Calendar.getInstance();cal.setTime(dt);int w = cal.get(Calendar.DAY_OF_WEEK) - 1;if (w < 0) {w = 0;}return weekDays[w];}/*** 时间⽐⼤⼩** @param DATE1* @param DATE2* @param pattern* @return*/public static int compareDate(String DATE1, String DATE2, String pattern) {DateFormat df = new SimpleDateFormat(pattern);try {Date dt1 = df.parse(DATE1);Date dt2 = df.parse(DATE2);if (dt1.getTime() > dt2.getTime()) {System.out.println("dt1 在dt2前");return 1;} else if (dt1.getTime() < dt2.getTime()) {System.out.println("dt1在dt2后");return -1;} else {return 0;}} catch (Exception exception) {exception.printStackTrace();}return 0;}/*** 在⼀个时间上加上或减去分钟** @param date long* @param i int* @return Date*/public static Date addOrMinusMinutes(Date date, int i) {Date rtn = null;GregorianCalendar cal = new GregorianCalendar();cal.setTime(date);cal.add(GregorianCalendar.MINUTE, i);rtn = cal.getTime();return rtn;}/*** 按照指定格式返回格式好的当前⽇期** @param dateFormat 默认yyyy-MM-dd* @return*/public static String getCurrentDateString(String dateFormat) {return DateUtil.format(new Date(), DATE_PATTERN.YYYY_MM_DD);}/*** 说明将⽇期格式化字符串，为null的返回空字符串** @param date* @return*/public static String format(Date date) {if (null == date) return "";SimpleDateFormat sf = new SimpleDateFormat(DATE_PATTERN.YYYY_MM_DD);return sf.format(date);}/*** 说明将⽇期格式化字符串，为null的返回空字符串** @param date ⽇期* @param dateFormat 格式化字符串，⽐如：yyyy-MM-dd* @return*/public static String format(Date date, String dateFormat) {if (null == dateFormat || "".equals(dateFormat)) return DateUtil.format(date);if (null == date) return "";SimpleDateFormat sf = new SimpleDateFormat(dateFormat);return sf.format(date);}/*** @param source 要进⾏解析的源字符串* @return* @说明将指定的字符串格解析成⽇期类型，格式默认为：yyyy-MM-dd*/public static Date parase(String source) {SimpleDateFormat sf = new SimpleDateFormat(DATE_PATTERN.YYYY_MM_DD);try {return sf.parse(source);} catch (ParseException e) {e.printStackTrace();}return null;}/*** @param source 要进⾏解析的源字符串* @param dateFormat 要解析的⽇期格式。
java美式时间格式,日期操作类（DateFormat与SimpleDateFormat）。。。
java美式时间格式,⽇期操作类（DateFormat与SimpleDateFormat）。
1.DateFormat类此类是⼀个⽇期的格式化类,专门格式化⽇期的操作,因为java.util.Date类本⾝就已经包含了完整的⽇期,所以只需要将些⽇期按照⼀些好的格式格式化⼀下显⽰就好了.观察DateFormat类的定义：此类是定义在java.test包中的。
public abstract class DateFormat extends Format但是定义上可以发现，此类是⼀个抽象类，按照以住的思路，直接使⽤其⼦类实例化即可，但是DateFormat 类本⾝的内部提供了可以直接为其实例化的操作。
得到⽇期的DateFormat对象：public static final DateFormat getDateInstance()得到⽇期时间的DateFormat对象：public static final DateFormat getDateTimeInstance()直接使⽤DateFormat类完成Date类的转换功能：public final String format(Date date)美式⽇期格式12345678910111213import java.text.DateFormat ;import java.util.Date ;public class DateDemo03{public static void main(String args[]){DateFormat df1 =null ;// 声明⼀个DateFormatDateFormat df2 =null ;// 声明⼀个DateFormatdf1 = DateFormat.getDateInstance() ;// 得到⽇期的DateFormat对象df2 = DateFormat.getDateTimeInstance() ;// 得到⽇期时间的DateFormat对象System.out.println("DATE：" + df1.format(new Date())) ;// 按照⽇期格式化System.out.println("DATETIME：" + df2.format(new Date())) ;// 按照⽇期时间格式化}};中式⽇期格式(通过Locale对象指定要显⽰的区域，指定的区域是中国)importjava.text.DateFormat ;importjava.util.Date ;importjava.util.Locale ;publicclassDateDemo04{publicstaticvoidmain(String args[]){DateFormat df1 = null;// 声明⼀个DateFormatDateFormat df2 = null;// 声明⼀个DateFormatdf1 = DateFormat.getDateInstance(DateFormat.YEAR_FIELD,newLocale("zh","CN")) ;// 得到⽇期的DateFormat对象df2 = DateFormat.getDateTimeInstance(DateFormat.YEAR_FIELD,DateFormat.ERA_FIELD,newLocale("zh","CN")) ;// 得到⽇期时间的DateFormat对象System.out.println("DATE："+ df1.format(newDate())) ;// 按照⽇期格式化System.out.println("DATETIME："+ df2.format(newDate())) ;// 按照⽇期时间格式化}}; 2.SimpleDateFormat类此类的功能是完成⽇期的显⽰格式化的，例如，在开发中，可以会将⼀种⽇期格式变为另外⼀种⽇期格式，如下所⽰：原始⽇期：2008-10-19 10:11:30.345转换捕⽇期：2008 年 10 ⽉ 19 ⽇ 10 点 11 分 30 秒 345 毫秒但是以上的两个⽇期中⽇期的数字是完全⼀样的，唯⼀不同的是⽇期的显⽰格式不同，所以要想实现这样的转换功能就必须依靠SimpleDateFormat类。
Java对日期Date类进行加减运算、年份加减月份加减、时间差等等
Java对⽇期Date类进⾏加减运算、年份加减⽉份加减、时间差等等实现代码⼀：import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;public class DateTestUtil {public static void main(String[] args) throws Exception {SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMdd");String str="20110823";Date dt=sdf.parse(str);Calendar rightNow = Calendar.getInstance();rightNow.setTime(dt);rightNow.add(Calendar.YEAR,-1);//⽇期减1年rightNow.add(Calendar.MONTH,3);//⽇期加3个⽉rightNow.add(Calendar.DAY_OF_YEAR,10);//⽇期加10天Date dt1=rightNow.getTime();String reStr = sdf.format(dt1);System.out.println(reStr);}}注：在Calendar对象的add⽅法中，第⼆个参数为正数表⽰“加”，负数表⽰“减”。
代码⼆： java date ⽇期加减天数测试类代码：import java.text.SimpleDateFormat;import java.util.Date;public class DateTest {public static void main(String[] arg){Date now = new Date();addAndSubtractDaysByGetTime(now,-5);addAndSubtractDaysByGetTime(now,5);addAndSubtractDaysByCalendar(now,-5);addAndSubtractDaysByCalendar(now,5);}public static Date addAndSubtractDaysByGetTime(Date dateTime/*待处理的⽇期*/,int n/*加减天数*/){//⽇期格式SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");SimpleDateFormat dd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(df.format(new Date(dateTime.getTime() + n * 24 * 60 * 60 * 1000L)));//System.out.println(dd.format(new Date(dateTime.getTime() + n * 24 * 60 * 60 * 1000L)));//注意这⾥⼀定要转换成Long类型，要不n超过25时会出现范围溢出，从⽽得不到想要的⽇期值return new Date(dateTime.getTime() + n * 24 * 60 * 60 * 1000L);}public static Date addAndSubtractDaysByCalendar(Date dateTime/*待处理的⽇期*/,int n/*加减天数*/){//⽇期格式SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");SimpleDateFormat dd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");java.util.Calendar calstart = java.util.Calendar.getInstance();calstart.setTime(dateTime);calstart.add(java.util.Calendar.DAY_OF_WEEK, n);System.out.println(df.format(calstart.getTime()));//System.out.println(dd.format(calstart.getTime()));return calstart.getTime();}}运⾏结果：2014-10-062014-10-162014-10-062014-10-16代码三：在⽹上查阅资料，加上⾃⼰总结的⼀些关于Date类的⼯具类。
date对象和calendar实例
date对象和calendar实例日期和时间在计算机科学中是至关重要的概念。
为了处理日期和时间，Java类库为我们提供了两种主要的类：Date对象和Calendar实例。
这两个类都是Java日期类。
Date类表示时间戳，即固定的时刻；而Calendar类则表示日期，可用于处理年，月和日等信息。
一、Date对象Date是Java中用来表示时间点的类。
对于Date对象，我们可以进行以下操作：1. 创建Date对象通过无参构造函数创建Date对象，该对象将包含当前日期和时间，例如：Date now = new Date();2. 获取当前日期和时间我们可以使用getTime方法获取当前日期和时间戳。
例如：long ts = now.getTime();3. 格式化日期我们可以使用SimpleDateFormat来为日期制定特定的格式。
这个类提供了一些格式，如yyyy-MM-dd HH:mm:ss。
例如：SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String dateString = format.format(now);二、Calendar实例Calendar是Java中另一种处理日期的类。
它可以使用以下操作：1. 获取当前时间Calendar calendar = Calendar.getInstance();2. 获取日期一个Calendar实例包含日期，可以使用以下方法获取日期：int year = calendar.get(Calendar.YEAR);int month = calendar.get(Calendar.MONTH) + 1;int day = calendar.get(Calendar.DAY_OF_MONTH);3. 设置日期我们可以使用以下方法设置日期：calendar.set(Calendar.YEAR, 2021);calendar.set(Calendar.MONTH, Calendar.JANUARY);calendar.set(Calendar.DAY_OF_MONTH, 1);4. 添加日期我们可以使用以下add方法添加日期：calendar.add(Calendar.DATE, 1);这将把当前的日期增加一天。
java date before和after的用法-概述说明以及解释
java date before和after的用法-概述说明以及解释1.引言1.1 概述在Java编程中，日期和时间的处理是一项重要的任务。
在处理日期和时间时，常常需要进行比较或者判断时间先后顺序的操作。
Java提供了Date类作为表示日期和时间的类，并且通过before和after方法提供了便捷的日期比较功能。
在本篇文章中，我们将深入探讨Java Date类的before和after方法的用法。
这两个方法可以用来比较两个日期的先后关系，并且返回相应的布尔值。
在接下来的正文部分，我们将首先介绍Java中的Date类，了解它的基本功能和使用方法。
然后，我们将详细讨论Date类的before方法和after方法，探讨它们的使用场景和注意事项。
最后，我们将对所学内容进行总结，并提供一些实际应用场景的示例，以帮助读者更好地理解和运用before和after方法。
通过学习本文，读者将能够全面掌握Java中Date类的before和after 方法的用法，从而在实际开发中更加灵活和高效地处理日期和时间的比较操作。
让我们开始探索吧！1.2文章结构《Java Date before和after的用法》文章结构：1. 引言1.1 概述1.2 文章结构文章将分为以下几个部分：- 正文部分将介绍Java中的Date类以及其常用的before和after方法的用法。
- 结论部分将对这两个方法的使用进行总结，并探讨它们在实际应用中的使用场景。
2. 正文2.1 Java中的Date类- 简要介绍Java中的Date类，提及其在日期和时间处理中的常用性。
2.2 Date类的before方法- 解释before方法的作用，即判断一个日期是否在另一个日期之前。
- 详细介绍before方法的使用方式，包括参数的含义和返回值的含义。
- 给出一些示例代码以帮助读者更好地理解before方法的实际应用。
2.3 Date类的after方法- 解释after方法的作用，即判断一个日期是否在另一个日期之后。