Check if a certain date is n years younger than a timestamp in android?

Question

I have a birthdate in integers:

int year, month, day;

and a timestamp.

long timestamp;

I'm going to check if the birthdate is n years (for example 2 years) younger than my timestamp. How can I do it?

The minimum API level is 15.

Answer 1

tl;dr

Instant                               // `Instant` = moment in UTC. Resolved in nanoseconds, much finer than the milliseconds seen in the Question.
.ofEpochMilli( 1_532_197_770_716L )   // Parse a count-from-epoch as an `Instant` object.
.atZone(                              // Adjust from UTC to a particular time zone.
    ZoneId.of( "America/Montreal" )   // Always use `Contintent/Region` formatted names, never the 3-4 letter pseudo-zones such as `PST` or `IST`.
)                                     // Returns a `ZonedDateTime` object. Think of it conceptually as: ZonedDateTime = ( Instant + ZoneId ). Represents the same moment, the same point on the timeline, but viewed through the lens of the wall-clock time used by the people of a particular region.
.toLocalDate()                        // Returns a `LocalDate`, date-only value without time-of-day and without time zone.
.minus(                               // Subtract a span-of-time.
    Period.ofYears( 2 )               // `Period` = a span of time unattached to the timeline, in granularity of a number of years-months-days.
)                                     // Returns another `LocalDate`. Using immutable objects pattern, producing a new object rather than altering (“mutating”) the original.
.isAfter(                             // Compare one `LocalDate` with another.
    LocalDate.of( yourYear , yourMonth , yourDay )
)                                     // Returns a boolean.

java.time

Parse your count of milliseconds since the epoch reference of first moment of 1970 in UTC as a Instant.

Instant instant = Instant.ofEpochMilli( millis ) ;

Adjust from UTC to the time zone in which you want to interpret a date. Understand that for any given moment, the date and time-of-day both vary around the globe by zone.

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( “Pacific/Auckland” ) ;
ZonedDateTime zdt = instant.atZone( z ) ;

Extract only the date portion, without the time-of-day and without the time zone.

LocalDate ld = zdt.toLocalDate() ;

Move backwards in time by your desired amount of time.

Period p = Period.ofYears( 2 ) ;
LocalDate twoYearsPrior = ld.minus( p ) ;

Represent the birthday.

LocalDate birthday = LocalDate.of( y , m , d ) ;

Compare.

Boolean x = birthday.isBefore( twoYearsPrior ) ;

---

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.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8, Java SE 9, Java SE 10, 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 (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

Answer 2

Try using joda time for lower versions.

private int checkDateDiff(long timestamp, int bdayYear, int bdayMonth, int bdayDay) {

    DateTime startDateTime = new DateTime(timestamp);

    DateTime endDateTime = new DateTime(bdayYear, bdayMonth, bdayDay, 0, 0);

    Period period = new Period(endDateTime, startDateTime);

    int yearsDiff = period.getYears();

    return yearsDiff;
}

Answer 3

This might work for you. Make Calendar objects and check the difference in the ms time between them. Basically just converting the date you had in integers to ms instead.

    int year, month, day;
    long timestamp;
    Calendar calendar = Calendar.getInstance();
    calendar.set(year, month+1, day);


    long twoYears = 63113852000L; //Two years in ms

    //Check if the difference is more than 2 years.
    if(calendar.getTimeInMillis() - timestamp >= twoYears || calendar.getTimeInMillis() - timestamp <= -twoYears) {
         System.out.println("More than 2 years dif");
    }