• 5星
12.76MB qq_31988139 2021-06-30 09:46:52
• I've followed two articles from a Java forum, Thread 1 / Thread 2. It works fine in a standalone program although when I include this into my logic to read from the report I get an unusual difference...


I need to find the number of days between two dates: one is from a report and one is the current date. My snippet:
int age=calculateDifference(agingDate, today);
Here calculateDifference is a private method, agingDate and today are Date objects, just for your clarification. I've followed two articles from a Java forum, Thread 1 / Thread 2.
It works fine in a standalone program although when I include this into my logic to read from the report I get an unusual difference in values.
Why is it happening and how can I fix it?
EDIT :
I'm getting a greater number of days compared to the actual amount of Days.
public static int calculateDifference(Date a, Date b)
{
int tempDifference = 0;
int difference = 0;
Calendar earlier = Calendar.getInstance();
Calendar later = Calendar.getInstance();
if (a.compareTo(b) < 0)
{
earlier.setTime(a);
later.setTime(b);
}
else
{
earlier.setTime(b);
later.setTime(a);
}
while (earlier.get(Calendar.YEAR) != later.get(Calendar.YEAR))
{
tempDifference = 365 * (later.get(Calendar.YEAR) - earlier.get(Calendar.YEAR));
difference += tempDifference;
}
if (earlier.get(Calendar.DAY_OF_YEAR) != later.get(Calendar.DAY_OF_YEAR))
{
tempDifference = later.get(Calendar.DAY_OF_YEAR) - earlier.get(Calendar.DAY_OF_YEAR);
difference += tempDifference;
}
return difference;
}
Note :
Unfortunately, none of the answers helped me solve the problem. I've accomplished this problem with the help of Joda-time library.
解决方案
I would suggest you use the excellent Joda Time library instead of the flawed java.util.Date and friends. You could simply write
import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.Days;
Date past = new Date(110, 5, 20); // June 20th, 2010
Date today = new Date(110, 6, 24); // July 24th
int days = Days.daysBetween(new DateTime(past), new DateTime(today)).getDays(); // => 34

展开全文
weixin_35663151 2021-07-16 22:32:24
• ## java中计算两个日期之间差的天数 java 计算天数差


展开全部
调用方式：
代码如下 复制代码
long date1 = getDateTime("20121201");//可改成自己的日期类型，但以“20121212”这种格式
long date2 = getDateTime("20121212");
int day = dateInterval(date1, date2);
System.out.println(day);
具体实现方法调用：
代码如下 复制代码
/**
* 计算出两个日期之间相差的天数
* 建议date1 大于 date2 这样计算的值为正数
* @param date1 日期1
* @param date2 日期2
* @return date1 - date2
*/
public static int dateInterval(long date1, long date2) {
if(date2 > date1){
date2 = date2 + date1;
date1 = date2 - date1;
date2 = date2 - date1;
}
// Canlendar 该类是一个抽象类
// 提供了丰富的日历字段
// 本程序中使用到了
// Calendar.YEAR 日期中的年份
// Calendar.DAY_OF_YEAR 当前年中的天数
// getActualMaximum(Calendar.DAY_OF_YEAR) 返回今年是 365 天还是366天
Calendar calendar1 = Calendar.getInstance(); // 获得一个日历
calendar1.setTimeInMillis(date1); // 用给定的 long 值设置此 Calendar 的当前时间值。
Calendar calendar2 = Calendar.getInstance();
calendar2.setTimeInMillis(date2);
// 先判断是否同年
int y1 = calendar1.get(Calendar.YEAR);
int y2 = calendar2.get(Calendar.YEAR);
int d1 = calendar1.get(Calendar.DAY_OF_YEAR);
int d2 = calendar2.get(Calendar.DAY_OF_YEAR);
int maxDays = 0;
int day = 0;
if(y1 - y2 > 0){
day = numerical(maxDays, d1, d2, y1, y2, calendar2);
}else{
day = d1 - d2;
}
return day;
}
/**
* 日期间隔计算
* 计算公式(示例):
* 20121201- 20121212
* 取出20121201这一年过了多少天 d1 = 天数 取出20121212这一年过了多少天 d2 = 天数
* 如果2012年这一年有366天就要让间隔的天数+1，因为2月份有29日。
* @param maxDays 用于记录一年中有365天还是366天
* @param d1 表示在这年中过了多少天
* @param d2 表示在这年中过了多少天
* @param y1 当前为2012年
* @param y2 当前为2012年
* @param calendar 根据日历对象来获取一年中有多少天
* @return 计算后日期间隔的天数
*/
public static int numerical(int maxDays, int d1, int d2, int y1, int y2, Calendar calendar){
int day = d1 - d2;
int betweenYears = y1 - y2;
List d366 = new ArrayList();
if(calendar.getActualMaximum(Calendar.DAY_OF_YEAR) == 366){
System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_YEAR));
day += 1;
}
for (int i = 0; i < betweenYears; i++) {
// 当年 + 1 设置下一年中有多少天
calendar.set(Calendar.YEAR, (calendar.get(Calendar.YEAR)) + 1);
maxDays = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
// 第一个 366 天不用 + 1 将所有366记录，先不进行加入然后再少加一个
if(maxDays != 366){
day += maxDays;
}else{
}
// 如果最后一个 maxDays 等于366 day - 1
if(i == betweenYears-1 && betweenYears > 1 && maxDays == 366){
day -= 1;
}
}
for(int i = 0; i < d366.size(); i++){
// 一个或一个以上的366天
if(d366.size() >= 1){
day += d366.get(i);
}
}
return day;
}
/**
* 将日期字符串装换成日期
* @param strDate 日期支持年月日 示例:yyyyMMdd
* @return 1970年1月1日器日期的毫秒数
*/
public static long getDateTime(String strDate) {
return getDateByFormat(strDate, "yyyyMMdd").getTime();
}
/**
* @param strDate 日期字符串
* @param format 日期格式
* @return Date
*/
public static Date getDateByFormat(String strDate, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
try{
return (sdf.parse(strDate));
}catch (Exception e){
return null;
}
}
例2
代码如下 复制代码
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class test16 {
/**
* @param args
* @throws ParseException
*/
public static void main(String[] args) throws ParseException {
// TODO Auto-generated method stub
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d1=sdf.parse("2012-09-08 10:10:10");
Date d2=sdf.parse("2012-09-15 00:00:00");
System.out.println(daysBetween(d1,d2));
System.out.println(daysBetween("2012-09-08 10:10:10","2012-09-15 00:00:00"));
}
/**
* 计算两个日期之间相差的天数
* @param smdate 较小的时间
* @param bdate 较大的时间
* @return 相差天数
* @throws ParseException
*/
public static int daysBetween(Date smdate,Date bdate) throws ParseException
{
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
smdate=sdf.parse(sdf.format(smdate));
bdate=sdf.parse(sdf.format(bdate));
Calendar cal = Calendar.getInstance();
cal.setTime(smdate);
long time1 = cal.getTimeInMillis();
cal.setTime(bdate);
long time2 = cal.getTimeInMillis();
long between_days=(time2-time1)/(1000*3600*24);
return Integer.parseInt(String.valueOf(between_days));
}
/**
*字符串的日期格式的计算
*/
public static int daysBetween(String smdate,String bdate) throws ParseException{
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(sdf.parse(smdate));
long time1 = cal.getTimeInMillis();
cal.setTime(sdf.parse(bdate));
long time2 = cal.getTimeInMillis();
long between_days=(time2-time1)/(1000*3600*24);
return Integer.parseInt(String.valueOf(between_days));
}
}
例3
代码如下 复制代码
//取得剩余天数
SimpleDateFormat df=new SimpleDateFormat("yyyymmdd");
Date d0=new java.util.Date();
Date d1=df.parse(end_date);
long time0=d0.getTime();
long time1=d1.getTime();
System.out.println((time1-time0)/(1000*60*60*24));
这样算两个时间相差的天数比较好
代码如下 复制代码
/**
* 计算两个日期之间相差的天数
*
* @param date1
* @param date2
* @return
*/
public static int diffdates(Date date1, Date date2) {
int result = 0;
ElapsedTime et = new ElapsedTime();
GregorianCalendar gc1 = new GregorianCalendar();
GregorianCalendar gc2 = new GregorianCalendar();
gc1.setTime(date1);
gc2.setTime(date2);
result = et.getDays(gc1, gc2);
return result;
}
然后ElapseTime中的方法是：
代码如下 复制代码
public int getDays(GregorianCalendar g1, GregorianCalendar g2) {
int elapsed = 0;
GregorianCalendar gc1, gc2;
if (g2.after(g1)) {
gc2 = (GregorianCalendar) g2.clone();
gc1 = (GregorianCalendar) g1.clone();
} else {
gc2 = (GregorianCalendar) g1.clone();
gc1 = (GregorianCalendar) g2.clone();
}
gc1.clear(Calendar.MILLISECOND);
gc1.clear(Calendar.SECOND);
gc1.clear(Calendar.MINUTE);
gc1.clear(Calendar.HOUR_OF_DAY);
gc2.clear(Calendar.MILLISECOND);
gc2.clear(Calendar.SECOND);
gc2.clear(Calendar.MINUTE);
gc2.clear(Calendar.HOUR_OF_DAY);
while (gc1.before(gc2)) {
elapsed++;
}
return elapsed;
}
其实使用joda最简单
代码如下 复制代码
public boolean isRentalOverdue(DateTime datetimeRented) {
Period rentalPeriod = Period.days(2);
return datetimeRented.plus(rentalPeriod).isBeforeNow()
}

已赞过
已踩过<
你对这个回答的评价是？
评论
收起

展开全文
weixin_42294495 2021-02-27 14:23:55
• ## Java-计算两个时间天数差 java 时间天数差

public static int getDaysBetween (String beginDate, String endDate) throws ParseException { ...//得到当年的实际天数 d1.add(Calendar.YEAR, 1); } while (d1.get(Calendar.YEAR) != y2); } return days; }

public static int getDaysBetween (String beginDate, String endDate) throws ParseException
{
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date bDate = format.parse(beginDate);
Date eDate = format.parse(endDate);
Calendar d1 = new GregorianCalendar();
d1.setTime(bDate);
Calendar d2 = new GregorianCalendar();
d2.setTime(eDate);
int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
int y2 = d2.get(Calendar.YEAR);
if (d1.get(Calendar.YEAR) != y2)
{
d1 = (Calendar) d1.clone();
do   {
days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);//得到当年的实际天数
}    while (d1.get(Calendar.YEAR) != y2);
}
return days;
}

展开全文
weixin_31556767 2021-03-22 14:43:49
• Java计算两个时间的天数差与月数差 LocalDateTime，如何计算日期差的天数/*** 计算两个时间点的天数差* @param dt1 第一个时间点* @param dt2 第二个时间点* @return int，即要计算的天数差*/public static int ...

Java计算两个时间的天数差与月数差 LocalDateTime，如何计算日期差的天数
/**
* 计算两个时间点的天数差
* @param dt1 第一个时间点
* @param dt2 第二个时间点
* @return int，即要计算的天数差
*/
public static int dateDiff(LocalDateTime dt1,LocalDateTime dt2){
//获取第一个时间点的时间戳对应的秒数
long t1 = dt1.toEpochSecond(ZoneOffset.ofHours(0));
//获取第一个时间点在是1970年1月1日后的第几天
long day1 = t1 /(60*60*24);
//获取第二个时间点的时间戳对应的秒数
long t2 = dt2.toEpochSecond(ZoneOffset.ofHours(0));
//获取第二个时间点在是1970年1月1日后的第几天
long day2 = t2/(60*60*24);
//返回两个时间点的天数差
return (int)(day2 - day1);
}
@Test
public void testDay(){
LocalDateTime of1 = LocalDateTime.of(2018, 9, 25, 1, 1);//2018-9-25 01:01
LocalDateTime of2 = LocalDateTime.of(2019, 9, 25, 23, 16); //2019-9-25 23:16
System.out.println(dateDiff(of1,of2));//365
}
/**
* 获取两个时间点的月份差
* @param dt1 第一个时间点
* @param dt2 第二个时间点
* @return int，即需求的月数差
*/
public static int monthDiff(LocalDateTime dt1,LocalDateTime dt2){
//获取第一个时间点的月份
int month1 = dt1.getMonthValue();
//获取第一个时间点的年份
int year1 = dt1.getYear();
//获取第一个时间点的月份
int month2 = dt2.getMonthValue();
//获取第一个时间点的年份
int year2 = dt2.getYear();
//返回两个时间点的月数差
return (year2 - year1) *12 + (month2 - month1);
}
@Test
public void testMonth(){
LocalDateTime of1 = LocalDateTime.of(2018, 9, 25, 1, 1);//2018-9-25 01:01
LocalDateTime of2 = LocalDateTime.of(2019, 9, 25, 23, 16); //2019-9-25 23:16
System.out.println(monthDiff(of1,of2));//12
}
相关文章暂无相关文章

展开全文
weixin_31362539 2021-03-30 08:03:10
• weixin_34206129 2021-03-09 05:16:11
• weixin_32691823 2021-07-19 18:31:15
• weixin_35871529 2021-02-26 11:13:03
• weixin_30315143 2021-01-27 01:37:46
• weixin_39744554 2021-04-16 16:35:00
• ## 用Java计算两个日期之间的天数 java日期计算天数

weixin_42511053 2021-02-12 14:18:33
• ## Java 计算两个日期相差的天数 java算时间差

weixin_28840811 2021-02-12 11:10:19
• ## Java8计算两个日期时间差 天数 时分秒 java

lineFirends 2021-08-23 11:46:32
• ## java计算两个日期之间天数 java

pic_good_life 2021-01-22 16:47:17
• weixin_39943442 2021-02-27 11:55:51
• weixin_31226805 2021-04-11 11:18:23
• ## java将两个日期相减得到天数 java两个日期相减

weixin_35991051 2021-03-07 02:58:54
• weixin_39826089 2021-02-28 12:06:31
• ## java判断两个日期相差天数 java

q1424966670 2021-09-02 17:30:23
• weixin_32715971 2021-03-08 06:50:34
• weixin_39692623 2021-03-05 22:09:42
• ## java计算两个日期相差的天数 开发语言

weixin_43449246 2021-11-25 14:39:17
• taxue1011 2020-06-28 16:53:22
• weixin_42783709 2021-02-25 19:34:52

...

java 订阅