We Keep Coding

Android calculate days between two dates

I have written the following code to find days between two dates
startDateValue = new Date(startDate);
endDateValue = new Date(endDate);
long diff = endDateValue.getTime() - startDateValue.getTime();
long seconds = diff / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = (hours / 24) + 1;
Log.d("days", "" + days);
When start and end date are 2/3/2017 and 3/3/2017 respectively the number of days showing is 29.Though when they are of the same day it is showing 1.(The number of days one takes a leave.So if one takes a single day leave,he has to select same start and end date.So in this case he has taken two days leave).
What am I doing wrong?
Thank you for your time.
Note: Please don't use the date constructor. Check the accepted answer below. Use simpledateformat or Joda time. Date constructor is deprecated.

Your code for generating date object:
Date date = new Date("2/3/2017"); //deprecated
You are getting 28 days as answer because according to Date(String) constructor it is thinking day = 3,month = 2 and year = 2017
You can convert String to Date as follows:
String dateStr = "2/3/2017";
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
Date date = sdf.parse(dateStr);
Use above template to make your Date object. Then use below code for calculating days in between two dates. Hope this clear the thing.
It can de done as follows:
long diff = endDateValue.getTime() - startDateValue.getTime();
System.out.println ("Days: " + TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS));
Please check link
If you use Joda Time it is much more simple:
int days = Days.daysBetween(date1, date2).getDays();
Please check JodaTime
How to use JodaTime in Java Project

Kotlin
Here is the example to calculate days from today to some date:
val millionSeconds = yourDate.time - Calendar.getInstance().timeInMillis
leftDays.text = TimeUnit.MILLISECONDS.toDays(millionSeconds).toString() + "days"
If you want to calculate two days, then change:
val millionSeconds = yourDate1.time - yourDate2.time
should work.

public static int getDaysDifference(Date fromDate,Date toDate)
{
if(fromDate==null||toDate==null)
return 0;
return (int)( (toDate.getTime() - fromDate.getTime()) / (1000 * 60 * 60 * 24));
}

Does Android fully support java-8? If yes you can simple use ChronoUnit class
LocalDate start = LocalDate.of(2017,2,3);
LocalDate end = LocalDate.of(2017,3,3);
System.out.println(ChronoUnit.DAYS.between(start, end)); // 28
or same thing using formatter
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("M/d/yyyy");
LocalDate start = LocalDate.parse("2/3/2017",formatter);
LocalDate end = LocalDate.parse("3/3/2017",formatter);
System.out.println(ChronoUnit.DAYS.between(start, end)); // 28

java.time and ThreeTenABP
If I understand correctly, you want the number of days from start day through end date inclusive.
DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("d/M/u");
String startDate = "2/3/2017";
String endDate = "3/3/2017";
LocalDate startDateValue = LocalDate.parse(startDate, dateFormatter);
LocalDate endDateValue = LocalDate.parse(endDate, dateFormatter);
long days = ChronoUnit.DAYS.between(startDateValue, endDateValue) + 1;
System.out.println("Days: " + days);
Output:
Days: 2
ChronoUnit.DAYS.between() gives us a count of days from start date inclusive to end date exclusive. So to include the end date too we needed to add 1 day just as you did in the question.
What went wrong in your code?
You are using the Date(String) constructor. This constructor has been deprecated since 1997 because it works unreliably across time zones, so don’t use it. Also it’s kind of magical: at least I never really know what I get. Apparently it takes 2/3/2017 to mean February 3, 2017, where you intended 2 March 2017. From February 3 to March 3 inclusive is 29 days (since 2017 wasn’t a leap year). This explains why you got 29. (If necessary, we could spell our way through the documentation and find out why 2/3/2017 is interpreted the way it is, only I’d find that a pointless waste of time to do.)
You can’t convert from milliseconds. Please also note that not only the question but also the very many answers that convert from milliseconds to days are incorrect. Such a conversion assumes that a day is always 24 hours. Because of summer time (DST) and other time anomalies a day is not always 24 hours. All of those answers will count a day too few for example if the leave crosses the spring gap or spring forward when summer time begins.
Question: Doesn’t java.time require Android API level 26?
java.time works nicely on both older and newer Android devices. It just requires at least Java 6.
In Java 8 and later and on newer Android devices (from API level 26) the modern API comes built-in.
In non-Android Java 6 and 7 get the ThreeTen Backport, the backport of the modern classes (ThreeTen for JSR 310; see the links at the bottom).
On (older) Android use the Android edition of ThreeTen Backport. It’s called ThreeTenABP. And make sure you import the date and time classes from org.threeten.bp with subpackages.
Links
Oracle tutorial: Date Time explaining how to use java.time.
Java Specification Request (JSR) 310, where java.time was first described.
ThreeTen Backport project, the backport of java.time to Java 6 and 7 (ThreeTen for JSR-310).
ThreeTenABP, Android edition of ThreeTen Backport
Question: How to use ThreeTenABP in Android Project, with a very thorough explanation.

What date format do you use? Is it d/M/yyyy or M/d/yyyy?
d = day, M = month, yyyy = year
(see: https://developer.android.com/reference/java/text/SimpleDateFormat.html)
Then the codes:
public static final String DATE_FORMAT = "d/M/yyyy"; //or use "M/d/yyyy"
public static long getDaysBetweenDates(String start, String end) {
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT, Locale.ENGLISH);
Date startDate, endDate;
long numberOfDays = 0;
try {
startDate = dateFormat.parse(start);
endDate = dateFormat.parse(end);
numberOfDays = getUnitBetweenDates(startDate, endDate, TimeUnit.DAYS);
} catch (ParseException e) {
e.printStackTrace();
}
return numberOfDays;
}
And for getUnitBetweenDates method:
private static long getUnitBetweenDates(Date startDate, Date endDate, TimeUnit unit) {
long timeDiff = endDate.getTime() - startDate.getTime();
return unit.convert(timeDiff, TimeUnit.MILLISECONDS);
}

Very simple, just use Calendar, create two instances for the two dates, convert to milliseconds, subtract and convert to days (rounded up)... like this, basically:
Calendar startDate = Calendar.getInstance();
startDate.set(mStartYear, mStartMonth, mStartDay);
long startDateMillis = startDate.getTimeInMillis();
Calendar endDate = Calendar.getInstance();
endDate.set(mEndYear, mEndMonth, mEndDay);
long endDateMillis = endDate.getTimeInMillis();
long differenceMillis = endDateMillis - startDateMillis;
int daysDifference = (int) (differenceMillis / (1000 * 60 * 60 * 24));

Have look at this code , this is helpful for me ,hope it will help you.
public String get_count_of_days(String Created_date_String, String Expire_date_String) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy", Locale.getDefault());
Date Created_convertedDate = null, Expire_CovertedDate = null, todayWithZeroTime = null;
try {
Created_convertedDate = dateFormat.parse(Created_date_String);
Expire_CovertedDate = dateFormat.parse(Expire_date_String);
Date today = new Date();
todayWithZeroTime = dateFormat.parse(dateFormat.format(today));
} catch (ParseException e) {
e.printStackTrace();
}
int c_year = 0, c_month = 0, c_day = 0;
if (Created_convertedDate.after(todayWithZeroTime)) {
Calendar c_cal = Calendar.getInstance();
c_cal.setTime(Created_convertedDate);
c_year = c_cal.get(Calendar.YEAR);
c_month = c_cal.get(Calendar.MONTH);
c_day = c_cal.get(Calendar.DAY_OF_MONTH);
} else {
Calendar c_cal = Calendar.getInstance();
c_cal.setTime(todayWithZeroTime);
c_year = c_cal.get(Calendar.YEAR);
c_month = c_cal.get(Calendar.MONTH);
c_day = c_cal.get(Calendar.DAY_OF_MONTH);
}
/*Calendar today_cal = Calendar.getInstance();
int today_year = today_cal.get(Calendar.YEAR);
int today = today_cal.get(Calendar.MONTH);
int today_day = today_cal.get(Calendar.DAY_OF_MONTH);
*/
Calendar e_cal = Calendar.getInstance();
e_cal.setTime(Expire_CovertedDate);
int e_year = e_cal.get(Calendar.YEAR);
int e_month = e_cal.get(Calendar.MONTH);
int e_day = e_cal.get(Calendar.DAY_OF_MONTH);
Calendar date1 = Calendar.getInstance();
Calendar date2 = Calendar.getInstance();
date1.clear();
date1.set(c_year, c_month, c_day);
date2.clear();
date2.set(e_year, e_month, e_day);
long diff = date2.getTimeInMillis() - date1.getTimeInMillis();
float dayCount = (float) diff / (24 * 60 * 60 * 1000);
return ("" + (int) dayCount + " Days");
}

Be carefur if you'd like to use received integer e.g. to indicate specific day in custom calendar implementation. For example, I tried to go in m app from monthly calendar view to daily view and show daily content, by calculating dates from 1970-01-01 to selected one, and each 25-31th day of month shows me as one day earlier, because datesDifferenceInMillis / (24 * 60 * 60 * 1000); may return something like 17645,95833333333, and casting this to int you'll get value lower by 1. In this case correctly number of days you'll get by rounding received float by using NumberFormat class. Here's my code:
NumberFormat numberFormat = NumberFormat.getInstance(Locale.getDefault());
numberFormat.setRoundingMode(RoundingMode.HALF_UP);
numberFormat.setMaximumFractionDigits(0);
numberFormat.setMinimumFractionDigits(0);
int days = numberFormat.parse(numberFormat.format(value)).intValue();
I hope it will be helpful.

SUPER SIMPLE
use LocalDate() include implementation 'com.jakewharton.threetenabp:threetenabp:1.2.1' to use in android
Example
IN KOTLIN
val daysDifferene = LocalDate.of(2017,3,3).toEpochDay() - LocalDate.of(2017,3,2)
even better
create extension function to LocalDate class
private operator fun LocalDate.minus(other: LocalDate) = toEpochDay() - other.toEpochDay()
now just say
val daysDifference = localDate1 - localDate2 // you get number of days in Long type
IN JAVA
long daysDifference = LocalDate.of(2017,3,3).toEpochDay() - LocalDate.of(2107,3,2)

I modified Jitendra's answer in Kotlin:
fun getDaysBetweenDates(firstDateValue: String, secondDateValue: String, format: String): String
{
val sdf = SimpleDateFormat(format, Locale.getDefault())
val firstDate = sdf.parse(firstDateValue)
val secondDate = sdf.parse(secondDateValue)
if (firstDate == null || secondDate == null)
return 0.toString()
return (((secondDate.time - firstDate.time) / (1000 * 60 * 60 * 24)) + 1).toString()
}
and call it like
val days = getDaysBetweenDates("31-03-2020", "24-04-2020","dd-MM-yyyy")

fun countDaysBetweenTwoCalendar(calendarStart: Calendar, calendarEnd: Calendar) : Int{
val millionSeconds = calendarEnd.timeInMillis - calendarStart.timeInMillis
val days = TimeUnit.MILLISECONDS.toDays(millionSeconds) //this way not round number
val daysRounded = (millionSeconds / (1000.0 * 60 * 60 * 24)).roundToInt()
return daysRounded
}

while none of these worked for me, here is an easy way to implement your code with a very simple fonction :
private long getDaysDifference(Date fromDate,Date toDate) {
if(fromDate == null || toDate == null)
return 0;
int a = Integer.parseInt(DateFormat.format("dd", fromDate)+"");
int b = Integer.parseInt(DateFormat.format("dd", toDate)+"");
if ( b <= a){
return Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_MONTH) + b - a;
}
return b - a;
}
EnJoY

You can use joda time, it so simple
fun getBetweenDates(startDate: Long, endDate: Long): String {
val period = Period(startDate, endDate, PeriodType.yearMonthDayTime())
val formatter = PeriodFormatterBuilder()
.appendYears().appendSuffix(" year ")
.appendMonths().appendSuffix(" month ")
.appendDays().appendSuffix(" days ")
.appendHours().appendSuffix(" hours ")
.appendMinutes().appendSuffix(" minutes ")
.appendSeconds().appendSuffix(" seconds ")
.appendMillis().appendSuffix(" millis ")
.toFormatter()
return formatter.print(period)
}
start and end dates millisecond, and result example: "2 year 1 month ..."

use this way :
fun stringDateToCalendar(dateString: String?, formatString: String): Calendar? {
if (dateString == null || dateString.isEmpty() || formatString.isBlank())
return null
val inputDateFormat = SimpleDateFormat(formatString, Locale.ENGLISH)
return try {
inputDateFormat.parse(dateString)?.let {
val cal = Calendar.getInstance()
cal.time = it
cal
}
} catch (e: ParseException) {
null
}
}
val calendarFrom = stringDateToCalendar(
"2021-12-12",
"yyyy-MM-dd"
)
val calendarTo = CalendarUtils.stringDateToCalendar(
"2022-03-20",
"yyyy-MM-dd"
)
val msDiff = calendarTo?.timeInMillis?.minus(calendarFrom?.timeInMillis ?: 0) ?: 0
val daysDiff = TimeUnit.MILLISECONDS.toDays(msDiff)

Here the simply common function Kotlin code
Here comparing these formatted dates "2022-11-04", "2022-11-20"
Output will be 16 Days
open fun dateSubstraction(date1: String, date2: String): String {
val dateFormatter = SimpleDateFormat("yyyy-MM-dd") //Define input date format here
val formatedDate1= dateFormat.parse(date1) //formated date1
val formatedDate2= dateFormat.parse(date2) //formated date2
val millionSeconds = formatedDate2.time - formatedDate1.time
return TimeUnit.MILLISECONDS.toDays(millionSeconds).toString()+"Days"
}

I have done this work in past. This was very simple
val currentCalendar = Calendar.getInstance()
val targetCalendar = Calendar.getInstance().apply {
set(2023, Calendar.APRIL, 9, 23, 59, 59)
}//your input: date, month, and time
val difference = targetCalendar.timeInMillis - currentCalendar.timeInMillis
val differenceInDays = TimeUnit.MILLISECONDS.toDays(difference)
val remainingMonths = differenceInDays / 30//remaining months
val remainingDays = differenceInDays % 30//remaining days
val differenceInSeconds = TimeUnit.MILLISECONDS.toSeconds(difference)
val differenceInMinutes = TimeUnit.MILLISECONDS.toMinutes(difference)
val differenceInHours = TimeUnit.MILLISECONDS.toHours(difference)
val remainingSeconds = differenceInSeconds % 60//remaining seconds
val remainingMinutes = differenceInMinutes % 60//remaining minutes
val remainingHours = differenceInHours % 24// remaining hours
Thats It We have done it

Java: check if a given date is within current month

I need to check if a given date falls in the current month, and I wrote the following code, but the IDE reminded me that the getMonth() and getYear() methods are obsolete. I was wondering how to do the same thing in newer Java 7 or Java 8.
private boolean inCurrentMonth(Date givenDate) {
Date today = new Date();
return givenDate.getMonth() == today.getMonth() && givenDate.getYear() == today.getYear();
}

//Create 2 instances of Calendar
Calendar cal1 = Calendar.getInstance();
Calendar cal2 = Calendar.getInstance();
//set the given date in one of the instance and current date in the other
cal1.setTime(givenDate);
cal2.setTime(new Date());
//now compare the dates using methods on Calendar
if(cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)) {
if(cal1.get(Calendar.MONTH) == cal2.get(Calendar.MONTH)) {
// the date falls in current month
}
}

java.time (Java 8)
There are several ways to do it with the new java.time API (tutorial). You can do it using .get(ChronoField.XY), but I think this is prettier:
Instant given = givenDate.toInstant();
Instant ref = Instant.now();
return Month.from(given) == Month.from(ref) && Year.from(given).equals(Year.from(ref));
For better re-usability you can also refactor this code to "temporal query":
public class TemporalQueries {
//TemporalQuery<R> { R queryFrom(TemporalAccessor temporal) }
public static Boolean isCurrentMonth(TemporalAccessor temporal) {
Instant ref = Instant.now();
return Month.from(temporal) == Month.from(ref) && Year.from(temporal).equals(Year.from(ref));
}
}
Boolean result = givenDate.toInstant().query(TemporalQueries::isCurrentMonth); //Lambda using method reference

Time Zone
The other answers ignore the crucial issue of time zone. A new day dawns earlier in Paris than in Montréal. So at the same simultaneous moment, the dates are different, "tomorrow" in Paris while "yesterday" in Montréal.
Joda-Time
The java.util.Date and .Calendar classes bundled with Java are notoriously troublesome, confusing, and flawed. Avoid them.
Instead use either Joda-Time library or the java.time package in Java 8 (inspired by Joda-Time).
Here is example code in Joda-Time 2.5.
DateTimeZone zone = DateTimeZone.forID( "America/Montreal" );
DateTime dateTime = new DateTime( yourJUDate, zone ); // Convert java.util.Date to Joda-Time, and assign time zone to adjust.
DateTime now = DateTime.now( zone );
// Now see if the month and year match.
if ( ( dateTime.getMonthOfYear() == now.getMonthOfYear() ) && ( dateTime.getYear() == now.getYear() ) ) {
// You have a hit.
}
For a more general solution to see if a moment falls within any span of time (not just a month), search StackOverflow for "joda" and "interval" and "contain".

java.time (Java 8)
Java 8 provides the YearMonth class which represents a given month within a given year (e.g. January 2018). This can be used to compare against the YearMonth of the given date.
private boolean inCurrentMonth(Date givenDate) {
ZoneId timeZone = ZoneOffset.UTC; // Use whichever time zone makes sense for your use case
LocalDateTime givenLocalDateTime = LocalDateTime.ofInstant(givenDate.toInstant(), timeZone);
YearMonth currentMonth = YearMonth.now(timeZone);
return currentMonth.equals(YearMonth.from(givenLocalDateTime));
}
Note that this approach will work for any of the Java 8 time classes that have both a month and a date part (LocalDate, ZonedDateTime, etc.) and not just LocalDateTime.

As far as I know the Calendar class and all derived from it return the date using the get(). See the documentation for this class. Also here is an example taken from here:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy MMM dd HH:mm:ss");
Calendar calendar = new GregorianCalendar(2013,1,28,13,24,56);
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH); // Jan = 0, dec = 11
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR);
int weekOfMonth= calendar.get(Calendar.WEEK_OF_MONTH);
int hour = calendar.get(Calendar.HOUR); // 12 hour clock
int hourOfDay = calendar.get(Calendar.HOUR_OF_DAY); // 24 hour clock
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
int millisecond= calendar.get(Calendar.MILLISECOND);
System.out.println(sdf.format(calendar.getTime()));
System.out.println("year \t\t: " + year);
System.out.println("month \t\t: " + month);
System.out.println("dayOfMonth \t: " + dayOfMonth);
System.out.println("dayOfWeek \t: " + dayOfWeek);
System.out.println("weekOfYear \t: " + weekOfYear);
System.out.println("weekOfMonth \t: " + weekOfMonth);
System.out.println("hour \t\t: " + hour);
System.out.println("hourOfDay \t: " + hourOfDay);
System.out.println("minute \t\t: " + minute);
System.out.println("second \t\t: " + second);
System.out.println("millisecond \t: " + millisecond);
which outputs
2013 Feb 28 13:24:56
year : 2013
month : 1
dayOfMonth : 28
dayOfWeek : 5
weekOfYear : 9
weekOfMonth : 5
hour : 1
hourOfDay : 13
minute : 24
second : 56
millisecond : 0
I think it was replaced because the new way offers a much simpler handling using a single function, which is much easier to remember.

Android days left

I need to do the CountDown Days from one date to the second date
e.g
CURRENT_DATE:3/1/2013 NEXT_DATE:21/01/2013
then it displays ::17 DAYS LEFT
I implemented code like these
String inputDateString = "01/22/2013";
Calendar calCurr = Calendar.getInstance();
Calendar calNext = Calendar.getInstance();
calNext.setTime(new Date(inputDateString));
if(calNext.after(calCurr))
{
long timeDiff = calNext.getTimeInMillis() - calCurr.getTimeInMillis();
int daysLeft = (int) (timeDiff/DateUtils.DAY_IN_MILLIS);
dni.setText("Days Left: "+daysLeft);
}
else
{
long timeDiff = calCurr.getTimeInMillis() - calNext.getTimeInMillis();
timeDiff = DateUtils.YEAR_IN_MILLIS - timeDiff;
int daysLeft = (int) (timeDiff/DateUtils.DAY_IN_MILLIS);
}
Is there a better way to do achieve these?

Using Calendar's Methods:
String inputDateString = "01/22/2013";
Calendar calCurr = Calendar.getInstance();
Calendar day = Calendar.getInstance();
day.setTime(new SimpleDateFormat("MM/dd/yyyy").parse(inputDateString));
if(day.after(calCurr)){
System.out.println("Days Left: " + (day.get(Calendar.DAY_OF_MONTH) -(calCurr.get(Calendar.DAY_OF_MONTH))) );
}
Output: Days Left: 17
And to increment the year by 1 , you could use Calendar.add() method
day.add(Calendar.YEAR, 1);

There are several libraries to convert date to n days format:
PrettyTime
JodaTime

I use this class
import android.text.format.DateUtils;
import java.util.Date;
import static android.text.format.DateUtils.FORMAT_NUMERIC_DATE;
import static android.text.format.DateUtils.FORMAT_SHOW_DATE;
import static android.text.format.DateUtils.FORMAT_SHOW_YEAR;
import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
/**
* Utilities for dealing with dates and times
*/
public class TimeUtils {
/**
* Get relative time for date
*
* #param date
* #return relative time
*/
public static CharSequence getRelativeTime(final Date date) {
long now = System.currentTimeMillis();
if (Math.abs(now - date.getTime()) > 60000)
return DateUtils.getRelativeTimeSpanString(date.getTime(), now,
MINUTE_IN_MILLIS, FORMAT_SHOW_DATE | FORMAT_SHOW_YEAR
| FORMAT_NUMERIC_DATE);
else
return "Just now";
}
}
TimeUtils.getRelativeTime(date) returns text like
Just now,
2 min. ago,
2 hours ago,
2 days ago,
04.11.2013

tl;dr
java.time.temporal.ChronoUnit.DAYS.between(
LocalDate.now() ,
LocalDate.of( 2013 , Month.JANUARY , 21 )
)
java.time
The modern approach uses the java.time classes.
LocalDate
The LocalDate class represents a date-only value without time-of-day and without time zone.
Determine your dates.
LocalDate start = LocalDate.of( 2013 , Month.JANUARY , 3 ) ; // 3/1/2013
LocalDate stop = LocalDate.of( 2013 , Month.JANUARY , 21 ) ; // 21/01/2013
Today’s date
A time zone is crucial in determining a date. For any given moment, the date varies around the globe by zone. For example, a few minutes after midnight in Paris France is a new day while still “yesterday” in Montréal Québec.
If no time zone is specified, the JVM implicitly applies its current default time zone. That default may change at any moment, so your results may vary. Better to specify your desired/expected time zone explicitly as an argument.
Specify a proper time zone name in the format of continent/region, such as America/Montreal, Africa/Casablanca, or Pacific/Auckland. Never use the 3-4 letter abbreviation such as EST or IST as they are not true time zones, not standardized, and not even unique(!).
ZoneId z = ZoneId.of( "America/Montreal" ) ; // Or `ZoneId.systemDefault()` to indicate explicitly that you want the JVM’s current default time zone. Beware of that default changing *during* runtime.
LocalDate today = LocalDate.now( z ) ;
Elapsed days
The ChronoUnit enum calculates elapsed time in various granularity.
long daysElapsed = ChronoUnit.DAYS.between( start , stop ) ;
About java.time
The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.
The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.
To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.
Where to obtain the java.time classes?
Java SE 8, Java SE 9, and later
Built-in.
Part of the standard Java API with a bundled implementation.
Java 9 adds some minor features and fixes.
Java SE 6 and Java SE 7
Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
Android
Later versions of Android bundle implementations of the java.time classes.
For earlier Android, the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

I searched this code on internet, but didn't manage to find. Though I'm replying late, this will be useful piece of code.
public static String getTimeLeft(String date) { // dateFormat = "yyyy-MM-dd"
String[] DateSplit = date.split("-");
int month = Integer.parseInt(DateSplit[1]) - 1, // if month is november then subtract by 1
year = Integer.parseInt(DateSplit[0]), day = Integer
.parseInt(DateSplit[2]), hour = 0, minute = 0, second = 0;
Calendar now = Calendar.getInstance();
int sec = second - Calendar.getInstance().get(Calendar.SECOND), min = minute
- Calendar.getInstance().get(Calendar.MINUTE), hr = hour
- Calendar.getInstance().get(Calendar.HOUR_OF_DAY), dy = day
- Calendar.getInstance().get(Calendar.DATE), mnth = month
- Calendar.getInstance().get(Calendar.MONTH), daysinmnth = 32 - dy;
Calendar end = Calendar.getInstance();
end.set(year, month, day);
if (mnth != 0) {
if (dy != 0) {
if (sec < 0) {
sec = (sec + 60) % 60;
min--;
}
if (min < 0) {
min = (min + 60) % 60;
hr--;
}
if (hr < 0) {
hr = (hr + 24) % 24;
dy--;
}
if (dy < 0) {
dy = (dy + daysinmnth) % daysinmnth;
mnth--;
}
if (mnth < 0) {
mnth = (mnth + 12) % 12;
}
}
}
String hrtext = (hr == 1) ? "hour" : "hours", dytext = (dy == 1) ? "day"
: "days", mnthtext = (mnth == 1) ? "month" : "months";
if (now.after(end)) {
return "";
} else {
String months = "", days = "", hours = "";
months = (mnth > 0) ? mnth + " " + mnthtext : "";
if (mnth <= 0) {
days = (dy > 0) ? dy + " " + dytext : "";
if (dy <= 0) {
hours = (hr > 0) ? hr + " " + hrtext : "";
}
}
//Log.d("DATE", months + " 1 " + days + " 2 " + hours);
return months + days + hours;
}
}

The other answers ignore time zone, which may be crucial depending on how accurate you want your countdown. If you do not specify a time zone, you get the JVM's default.
The java.util.Date & .Calendar classes are notoriously troublesome. Avoid them. Use either Joda-Time or the new java.time package in Java 8.
A bit of code in Joda-Time 2.3, untested (off the top of my head). Search StackOverflow for many more examples.
String input = "01/22/2013";
DateTimeZone timeZone = DateTimeZone.forID( "Europe/Paris" );
DateTimeFormatter formatterInput = DateTimeFormat.forPattern( "MM/dd/yyyy" ).withZone( timeZone );
DateTime future = formatterInput.parseDateTime( input );
DateTime now = new DateTime( timeZone );
int days = Days.daysBetween( now, future ).getDays();
Interval interval = new Interval( now, future );
Period period = new Period( interval );
Do some System.out.println calls for those variables and be amazed.
The string format you'll see is ISO 8601. You can create other formats as well.

unable to get difference of days between two dates in java

I want to calculate the difference of days between two dates. My code works fine when the year of the date does not change, but when I calculate the difference between two dates like so: (13/01/2012 to 13/12/2011), it gives a negative value. It also gives wrong values of difference when I calculate the difference between today's date and a future date. Please help me. Thank you in advance. Here is my code:
//getting values from text box
String fromtext = from.getText().toString();
String totext = to.getText().toString();
//sdf if a simple date formatter
SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
Date fromdate = (Date) sdf.parse(fromtext);
Date todate = (Date) sdf.parse(totext);
Calendar fromcal = Calendar.getInstance();
Calendar tocal = Calendar.getInstance();
fromcal.setTime(fromdate);
tocal.setTime(todate);// setting to date
int reportDays=(int)(todate.getTime()-fromdate.getTime())/(3600*24*1000);
please tell me what is the best way to calculate the difference in days.

Dates input : 13/01/2012, 13/12/2011
format seems dd/MM/yyyy and you are using wrong one (i.e. MM/dd/yyyy)

tl;dr
ChronoUnit.DAYS.between(
LocalDate.parse( "13/01/2012" , DateTimeFormatter.ofPattern( "dd/MM/uuuu" ) ) ,
LocalDate.parse( "13/12/2011" , DateTimeFormatter.ofPattern( "dd/MM/uuuu" ) )
)
Using java.time
Much easier with the modern java.time classes that supplant the troublesome old legacy date-time classes such as Date & Calendar.
(13/01/2012 to 13/12/2011),
The LocalDate class represents a date-only value without time-of-day and without time zone.
DateTimeFormatter f = DateTimeFormatter.ofPattern( "dd/MM/uuuu" );
LocalDate start = LocalDate.parse( "13/01/2012" , f );
LocalDate stop = LocalDate.parse( "13/12/2011" , f );
Use ChronoUnit to calculate elapsed days.
long days = ChronoUnit.DAYS.between( start , stop );
Of course the number of days is negative when going back in time. Notice how your stop date is earlier than your start date.
A time zone is crucial in determining a date. For any given moment, the date varies around the globe by zone. For example, a few minutes after midnight in Paris France is a new day while still “yesterday” in Montréal Québec.
Specify a proper time zone name in the format of continent/region, such as America/Montreal, Africa/Casablanca, or Pacific/Auckland. Never use the 3-4 letter abbreviation such as EST or IST as they are not true time zones, not standardized, and not even unique(!).
ZoneId z = ZoneId.of( "America/Montreal" );
LocalDate today = LocalDate.now( z );
You can use ChronoUnit again to count days into the future.
long days = ChronoUnit.DAYS.between( today , today.plusMonths( 7 ) );
About java.time
The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.
The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.
To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.
Where to obtain the java.time classes?
Java SE 8 and SE 9 and later
Built-in.
Part of the standard Java API with a bundled implementation.
Java 9 adds some minor features and fixes.
Java SE 6 and SE 7
Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
Android
The ThreeTenABP project adapts ThreeTen-Backport (mentioned above) for Android specifically.
See How to use ThreeTenABP….
The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.

In addition to the format issue already mentionned, you are likely to have an overflow.
Try this:
int reportDays=(int)((todate.getTime()-fromdate.getTime())/(3600*24*1000));

I think you should try better googling....
http://www.java2s.com/Code/Java/Development-Class/DateDiffcomputethedifferencebetweentwodates.htm

Using joda time would be the simplest way.

check this code:
import java.util.Calendar;
public class DateDifferent{
public static void main(String[] args){
Calendar calendar1 = Calendar.getInstance();
Calendar calendar2 = Calendar.getInstance();
calendar1.set(2007, 01, 10);
calendar2.set(2007, 07, 01);
long milliseconds1 = calendar1.getTimeInMillis();
long milliseconds2 = calendar2.getTimeInMillis();
long diff = milliseconds2 - milliseconds1;
long diffSeconds = diff / 1000;
long diffMinutes = diff / (60 * 1000);
long diffHours = diff / (60 * 60 * 1000);
long diffDays = diff / (24 * 60 * 60 * 1000);
System.out.println("\nThe Date Different Example");
System.out.println("Time in milliseconds: " + diff + " milliseconds.");
System.out.println("Time in seconds: " + diffSeconds + " seconds.");
System.out.println("Time in minutes: " + diffMinutes + " minutes.");
System.out.println("Time in hours: " + diffHours + " hours.");
System.out.println("Time in days: " + diffDays + " days.");
}
}

Here's a simple little class I wrote for this purpose:
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DifferenceInDays
{
public int dateOffset(String incomingDate) throws ParseException
{
// parse dates
DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
Date date = (Date) formatter.parse(incomingDate);
// convert to milliseconds
long millisecs = date.getTime();
// convert to days
int offsetInDays = (int) Math.abs(millisecs / (1000 * 60 * 60 * 24));
return offsetInDays;
}
}
It takes care of negative offsets using the absolute value method.

If you try this with a locale that has daylight saving, and the from and to dates are before and after a daylight saving change the result may be different by 1 day. This is because Date and Calendar use timezones.
If you are only going to be dealing with dates between the years 1900 and 2100, there is a simple calculation which will give you the number of days since 1900:
public static int daysSince1900(Date date) {
Calendar c = new GregorianCalendar();
c.setTime(date);
int year = c.get(Calendar.YEAR);
if (year < 1900 || year > 2099) {
throw new IllegalArgumentException("daysSince1900 - Date must be between 1900 and 2099");
}
year -= 1900;
int month = c.get(Calendar.MONTH) + 1;
int days = c.get(Calendar.DAY_OF_MONTH);
if (month < 3) {
month += 12;
year--;
}
int yearDays = (int) (year * 365.25);
int monthDays = (int) ((month + 1) * 30.61);
return (yearDays + monthDays + days - 63);
}
Thus, to get the difference in days between two dates, you calculate their days since 1900 and calc the difference. Our daysBetween method looks like this:
public static Integer getDaysBetween(Date date1, Date date2) {
if (date1 == null || date2 == null) {
return null;
}
int days1 = daysSince1900(date1);
int days2 = daysSince1900(date2);
if (days1 < days2) {
return days2 - days1;
} else {
return days1 - days2;
}
}
And don't ask me where this calculation came from because we've used it since the early '90s.

I would do it like this!
package javaapplication2;
//#author Ibrahim Yesilay
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class JavaApplication2 {
public static void main(String[] args) throws ParseException {
Scanner scan = new Scanner(System.in);
System.out.println("First dates Day :");
int d = scan.nextInt();
System.out.println("First dates Mounth :");
int m = scan.nextInt();
System.out.println("First dates Year :");
int y = scan.nextInt();
String date;
date = Integer.toString(d) + "/" + Integer.toString(m) + "/" + Integer.toString(y);
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
Date firstdate = null;
firstdate = dateFormat.parse(date);
System.out.println(dateFormat.format(firstdate));
System.out.println("Second dates Day :");
d = scan.nextInt();
System.out.println("Second dates Month :");
m = scan.nextInt();
System.out.println("Second dates Year :");
y = scan.nextInt();
date = Integer.toString(d) + "/" + Integer.toString(m) + "/" + Integer.toString(y);
Date seconddate = null;
seconddate = dateFormat.parse(date);
System.out.println(dateFormat.format(seconddate));
if (seconddate.getTime() > firstdate.getTime()) {
long sonuc = (long)(seconddate.getTime()- firstdate.getTime())/(3600*24*1000);
System.out.println("" + sonuc);
} else if (firstdate.getTime() > seconddate.getTime()) {
long sonuc = (long)(firstdate.getTime()- seconddate.getTime())/(3600*24*1000);
System.out.println("" + sonuc);
} else {
System.out.println("The dates are equal!");
}
}
}

How to get all dates of sundays in a particular year in Java?

I am seriously looking for this code...I am new programmer.
Actually I want to make all dates with flag, which all are sunday in a particular year.
Please, I am eagerly waiting for your response....

Create a new calendar. Set the time to 1/1/yyyy and some time. Check if the current date is a Sunday and roll forward one day until it is. That's the first Sunday of the year. Roll forward 7 days until the year no longer matches, marking as you go.

Study the the docs of java.util.Calendar carefully.

If i was doing it I would use Joda Time to find the first Sunday in the year using LocalDate. Create 1st of Jan and then add 1 day until it is a Sunday, then add 7 days until your run out of year.
LocalDate date = new LocalDate(YEAR, 1, 1);
while ( date.dayOfWeek() != 7 )
{
date = date.addDays(1);
}
while ( date.year() == YEAR )
{
date = date.addDays(7);
}
Or something like that.

Something like this should work.
int year = 2009;
Calendar cal = new GregorianCalendar(year, Calendar.JANUARY, 1);
for (int i = 0, inc = 1; i < 366 && cal.get(Calendar.YEAR) == year; i+=inc) {
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
// this is a sunday
cal.add(Calendar.DAY_OF_MONTH, 7);
inc = 7;
} else {
cal.add(Calendar.DAY_OF_MONTH, 1);
}
}

This is an example code using java.util.Calendar and java.util.GregorianCalendar that prints out each Sunday of the year 2009.
A lot of optimizing can be done in formatting the date, but i'll leave that as an exercise for you.
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Test
{
public static void main(String[] args)
{
int year =2009;
int dayOfWeek = Calendar.SUNDAY;
String dayOfWeekString = "Sunday";
// instantiate Calender and set to first Sunday of 2009
Calendar cal = new GregorianCalendar();
cal.set(2009, 0, 1, 0, 0); cal.getTime();
cal.set(Calendar.DAY_OF_WEEK, dayOfWeek); cal.getTime();
int i = 1;
while (cal.get(Calendar.YEAR) == 2009)
{
System.out.println(dayOfWeekString + " " + i + ": " + cal);
cal.add(Calendar.DAY_OF_MONTH, 7);
i++;
}
}
}
As you can see, TiGz's way of using Joda Time is a lot simpler.

List arrList = new ArrayList();
SimpleDateFormat format1 = new SimpleDateFormat("dd-M-yyyy");
Date date = null;
Calendar cal = Calendar.getInstance();
for (int i = 0; i <= 51; i++)
{
try
{
cal.add(Calendar.WEEK_OF_YEAR, +1);
cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
String formatted = format1.format(cal.getTime());
date = format1.parse(formatted);
arrList.add(date);
} catch (Exception e) {
e.printStackTrace();
}
}

java.time
Java 8 and later comes with the new java.time package. Inspired by Joda-Time, defined by JSR 310, extended by the ThreeTen-Extra project. These new classes supplant the notoriously troublesome java.util.Date/.Calendar & java.text.SimpleDateFormat and such.
Note that we specify a time zone, crucial for determining a date. For example, a new day dawns earlier in Paris than in Montréal.
ZoneId zoneId = ZoneId.of( "America/Montreal" ); // Time zone is crucial in determining the date. A new day dawns earlier in Paris than In Montréal, for example.
You would write this code to use only LocalDate without any time-of-day. But in business, the full date-time is often more useful. So my example here uses ZonedDateTime.
To be neat, I want the time-of-day set to first moment of the day. You might assume that means 00:00:00.0 but not always because of anomalies such as Daylight Saving Time. To soft-code this first-moment, we want to call the atStartOfDay method found on LocalDate. So we start with LocalDate, then use that method to get a ZonedDateTime object.
Again, note that we specify a time zone when getting today’s date. A very common mistake is to omit time zone. When omitted, the JVM’s current default time zone will be implicitly applied. That means your results can vary by machine or by admin’s settings. Even worse, any code in any thread of any app within this JVM can make a call to change that default time zone at any moment during runtime while your app executes! So always specify rather than rely implicitly on current default.
LocalDate today = LocalDate.now( zoneId ); // We want a ZonedDateTime, but starting with a LocalDate in order to get first moment of the day (see next line).
ZonedDateTime todayStart = today.atStartOfDay( zoneId ); // Set time-of-day to first moment of this date, just to be neat. Usually that time is '00:00:00.0' but not always.
The java.time framework includes some handy TemporalAdjustors to get first day of year, and from there, the first Sunday of that month.
ZonedDateTime firstOfThisYear = todayStart.with( TemporalAdjusters.firstDayOfYear( ) );
ZonedDateTime zdtFirstOfNextYear = firstOfThisYear.with( TemporalAdjusters.firstDayOfNextYear( ) );
ZonedDateTime firstSundayOfThisYear = firstOfThisYear.with( TemporalAdjusters.dayOfWeekInMonth( 1, DayOfWeek.SUNDAY ) );
Now we are set to loop through all the weeks of the year. We increment a week at a time until we find ourselves in the next year. We collect each Sunday in a List.
ZonedDateTime zdt = firstSundayOfThisYear; // Var changing throughout loop.
List< ZonedDateTime > sundays = new ArrayList<>( 53 ); // Set initial capacity to maximum number of values.
while ( zdt.isBefore( zdtFirstOfNextYear ) ) {
// Handle this iteration.
sundays.add( zdt );
System.out.println( "Sunday # " + sundays.size( ) + " : " + zdt );
// Prepare next iteration.
zdt = zdt.plusWeeks( 1 );
}
When run.
Sunday # 1 : 2015-01-04T00:00-05:00[America/Montreal]
Sunday # 2 : 2015-01-11T00:00-05:00[America/Montreal]
…
Sunday # 51 : 2015-12-20T00:00-05:00[America/Montreal]
Sunday # 52 : 2015-12-27T00:00-05:00[America/Montreal]

A year has approximately 365 days, so the Big-O's n is pretty manageable. I'd say just iterate from the beginning of the year through to the last day of the year, and check if each day is a Sunday or not.
You need at least Calendar.get(), Calendar.DAY_OF_WEEK and Calendar.SUNDAY

I recently developed [Lamma Date] which is designed to serve this type of use cases.
Following code will print out all Sundays in 2014:
List<Date> sundays2014 = Dates.from(2014, 1, 1).to(2014, 12, 31).byWeek().on(DayOfWeek.SUNDAY).build();
for(Date date: sundays2014) {
System.out.println(date);
}

**this will give u all Sundays of the year **
invented By me and friend Hemant
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class Test {
public static void main(String[] args) {
SimpleDateFormat format =new SimpleDateFormat("dd-MMM-yyyy");
String DATE_FORMAT = "yyyy MM dd";
SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
Calendar c1 = Calendar.getInstance(); // today
String y=sdf.format(c1.getTime());
String years=y.substring(0,4);
int year=Integer.parseInt(years);
//Connection con=null;
Calendar cal = new GregorianCalendar(year, Calendar.JANUARY, 1);
for (int i = 0, inc = 1; i <366 && cal.get(Calendar.YEAR) == year; i+=inc) {
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
// this is a sunday
String frm="";
frm=format.format(cal.getTime());
//System.out.println("From :"+frm);
System.out.println("the value of the sunday is "+format.format(cal.getTime()));
cal.add(Calendar.DAY_OF_MONTH, 7);
} else {
cal.add(Calendar.DAY_OF_MONTH, 1);
}
}
}
}