java两个日期之间的天数_java计算两个日期之间的天数

❶ 怎么求java，2个日期之间有多少天。。

用毫秒数计算已经不是正确方法了。原因是大销携夏令时间会造成计算错误。差一小时就是差一天。如果对这方面有疑问，可以补充问题，我再详细解答。
虽然在国内运用没有问题滚伏，但是如果用于国际化的金融系统就不行了。
所以建议你在学习阶段就认知，现代标准就是尽量不要使用毫秒数计算日期。

以下是斗渗正确方法：

public static long daysBetween(Calendar startDate, Calendar endDate) {
Calendar date = (Calendar) startDate.clone();
long daysBetween = 0;
while (date.before(endDate)) {
date.add(Calendar.DAY_OF_MONTH, 1);
daysBetween++;
}
return daysBetween;
}

❷ 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<Integer> d366 = new ArrayList<Integer>();

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{
d366.add(maxDays);
}
// 如果最后一个 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)) {
gc1.add(Calendar.DATE, 1);
elapsed++;
}
return elapsed;
}

其实使用joda最简单
代码如下复制代码

public boolean isRentalOvere(DateTime datetimeRented) {
Period rentalPeriod = Period.days(2);
return datetimeRented.plus(rentalPeriod).isBeforeNow()
}

❸ 用java写一个程序可以计算2个日期之间的天数差。

importjava.util.*;
publicclassMyDate{
intday;
intmonth;
intyear;
publicMyDate(){}
publicMyDate(intday,intmonth,intyear){
this.day=day;
this.month=month;
this.year=year;
}
publicvoidfuntion(MyDated){
intnewDay=d.day;
册凳intnewMonth=d.month;
intnewYear=d.year;
Calendarc1=Calendar.getInstance();
梁卖c1.set(newYear,newMonth,newDay);
longn1=c1.getTimeInMillis();
Calendarc2=Calendar.getInstance();
c2.set(year,month,day);
longn2=c2.getTimeInMillis();
System.out.println("相差天数为:"+Math.abs((n1-n2)/24/3600000));}
publicstaticvoidmain(String[]args){
MyDated1=newMyDate(1,1,2008);
MyDated2=橡姿逗newMyDate(2,1,2001);
d1.funtion(d2);
}
}

❹ java中知道两个日期如何获得两个日期之间的天数

importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Calendar;
importjava.util.Date;

publicclassTest{

	publicstaticvoidmain(String[]args){
		try{
			//时间转换类
			SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-dd");
			Datedate1=sdf.parse("2014-1-10");
			Datedate2=sdf.parse("2012-12-20");
			//将转换的两个时间对象转换成Calendard对象
			Calendarcan1=Calendar.getInstance();
			can1.setTime(date1);
			Calendarcan2=Calendar.getInstance();
			can2.setTime(date2);
			//拿出两个年份
			intyear1=can1.get(Calendar.YEAR);
			intyear2=can2.get(Calendar.YEAR);
			//天数
			intdays=0;
			Calendarcan=null;
			//如果can1<can2
			//减去小的时间在这一年已经过了的天数
			//加上大的时间已过的天数
			if(can1.before(can2)){
				days-=can1.get(Calendar.DAY_OF_YEAR);
				days+=can2.get(Calendar.DAY_OF_YEAR);
				can=can1;
			}else{
				days-=can2.get(Calendar.DAY_OF_YEAR);
				days+=can1.get(Calendar.DAY_OF_YEAR);
				can=can2;
			}
			for(inti=0;i<Math.abs(year2-year1);i++){
				//获取小的时间当前年的总天数
				days+=can.getActualMaximum(Calendar.DAY_OF_YEAR);
				//再计算下一年。
				can.add(Calendar.YEAR,1);
			}
			System.out.println("天数差："+days);
		}catch(ParseExceptione){
			e.printStackTrace();
		}
	}
}

Console:
天数差：386

❺ JAVA计算两个日期之间相差的天数

public static int countDays(String begin,String end){
int days = 0;

DateFormat df = new SimpleDateFormat("yyyy-MM-dd"判御);
Calendar c_b = Calendar.getInstance();
Calendar c_e = Calendar.getInstance();

try{
c_b.setTime(df.parse(begin));
c_e.setTime(df.parse(end));

while(c_b.before(c_e)){
days++;
c_b.add(Calendar.DAY_OF_YEAR, 1);
}

}catch(ParseException pe){
System.out.println("掘肆岩日期格式必须为：yyyy-MM-dd；雹卖如：2010-4-4.");
}

return days;
}

❻ java怎么计算两个日期相差几天

java可以使用计算日期的天数差，以下是详细代码：

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));
}

}

❼ 用java编写，两个日期之间相差的天数，求具体解法

DateFormatdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
try

{

Dated1=df.parse("2004-03-2613:31:40");

Dated2=df.parse("2004-01-0211:30:24");
longdiff=d1.getTime()-d2.getTime();//这样得到的差值是微秒级别
longdays=diff/(1000*60*60*24);

longhours=(diff-days*(1000*60*60*24))/(1000*60*60);
longminutes=(diff-days*(1000*60*60*24)-hours*(1000*60*60))/(1000*60);
System.out.println(""+days+"天"+hours+"小时"+minutes+"分"侍茄);

}
catch(Exceptione)
{
}

d1 d2就是2个日期，打印出来的是天小时告燃和分你可以自己转换一老友察下变成天

❽ java中怎么计算两个日期之间的天数

java.text.SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// java.util.Calendar calendar = Calendar.getInstance();
//
// Date today = sdf.parse(sdf.format(new Date())); //将今天的日期格式化成 yyyy-MM-dd
// Date chooseDate = sdf.parse("2015-10-01"); //将选择是日期转换成Date
// long t = chooseDate.getTime() - today.getTime(); //计算两个日期的时间差
// long d = t / (1000 * 60 * 60 * 24); //计算两个日期相差的天数

❾ 如何用java计算两个日期之间的天数

手头没有编码的工具，只能给你一个思路了。

先把两个日期分别设置到两个Date（java.util.Date）里。然后用getTime函数取得两者的毫秒数，两者之差除以一天的毫秒数(8640000)即为两个日期之间天数。

导航:首页 > 编程语言 > java两个日期之间的天数

java两个日期之间的天数

与java两个日期之间的天数相关的资料