Check if date is one week before from today Java

Question

I am trying to check if a particular date is one week before from today's date. I formatted my date into this format:

SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy hh:mm a");

Then, I get the list of date from a for loop by these code:

Date formattedToday = formatter.parse(todayStr);
Date formattedExpired = formatter.parse(expiredDate);

The example of dates in the list are:

09/12/2017 08:09 PM
10/24/2015 02:09 AM
07/18/2018 03:10 AM

I tried to follow this thread but I am not allowed to add in any external libraries.

The other solution that requires Java 8 is not applicable for me also as my current min API is 25 but ChronoUnit requires API 26 .

Any ideas? Thanks!

Answer 1

Using only Date and Calendar classes (and thus, compatible with any JVM from about 4-ish, I think?) you could try this sort of solution:

1. Get today as a Date : Date now = new Date()
2. Get one week ago from that, as a Calendar : Calendar expected = Calendar.getInstance(); expected.setTime(now); lastWeek.add(Calendar.WEEK_OF_YEAR, -1); Calendar expected = Calendar.getInstance(); expected.setTime(now); lastWeek.add(Calendar.WEEK_OF_YEAR, -1);
3. Get your expired date as a Calendar : Calendar actual = Calendar.getInstance().setTime(expiredDate);
4. Compare the year and day of year of the two calendars (you can compare other fields, but those two should be enough): return (expected.get(Calendar.YEAR) == actual.get(Calendar.YEAR)) && (expected.get(Calendar.WEEK_OF_YEAR) == actual.get(Calendar.WEEK_OF_YEAR));

Using this, you should be able to come up with an even shorter snippet that subtracts a week from now and compares the long values of the two. Though obviously that wouldn't be comparing calendar dates, it would be comparing nanoseconds :)

Answer 2

Here is a complete solution:

import java.util.Calendar;
import java.util.Date;

/**
 * @author Jeremi Grenier-Berthiaume
 */
public class InternalDate {

    private int year = 0;
    private int month = 0;
    private int day = 0;


    private InternalDate(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    private static InternalDate generateFromCalendar(Calendar calendar) {

        int lYear = calendar.get(Calendar.YEAR);
        int lMonth = calendar.get(Calendar.MONTH) + 1; // January = 1st month
        int lDay = calendar.get(Calendar.DAY_OF_MONTH);

        return new InternalDate(lYear, lMonth, lDay);
    }

    /**
     * Constructor for a textual format.
     *
     * @param text  Format "DD/MM/YYYY" followed by more chars which will be ignored if they are present.
     * @return      Associated InternalDate
     */
    private static InternalDate generateDateFromText(String text) {

        int year, month, day;
        char selectedChar = '/';
        text = text.substring(0,10); // to remove hours

        // Extract the data required to construct the InternalDate
        String[] splitDateText = text.split(""+selectedChar);
        day = Integer.parseInt(splitDateText[0]);
        month = Integer.parseInt(splitDateText[1]);
        year = Integer.parseInt(splitDateText[2]);

        return new InternalDate(year, month, day);
    }

    private static InternalDate getLastWeek() {

        // Get current date
        Calendar tempCal = Calendar.getInstance();
        tempCal.setTime(new Date());

        // 7 days ago
        tempCal.add(Calendar.DAY_OF_MONTH, -7);

        return generateFromCalendar(tempCal);
    }

    public static boolean isLastWeek(String compared) {

        int tmpDate = Integer.parseInt(InternalDate.getLastWeek().getComparableStringDate());
        int tmpCompDate = Integer.parseInt(InternalDate.generateDateFromText(compared).getComparableStringDate());

        return tmpDate == tmpCompDate;
    }
}

Forming the date that you want to verify as a string of the format DD/MM/YYYY and giving it in input to InternalDate.isLastWeek(stringDate); will give you an answer (it returns a boolean: true if it's a date from a week ago, false if not).

A nice and simple one-liner that you can call from anywhere in your app. Feel free to mark as an answer if it did respond to your question properly. :)

Answer 3

tl;dr

ZonedDateTime
.now()                           // Captures current moment as seen by the wall-clock time of the JVM’s current default time zone. Better to pass the optional `ZoneId` argument to specify explicitly the desired/expected time zone.
.minusWeeks( 1 )
.isAfter(
    LocalDateTime
    .parse( 
        "09/12/2017 08:09 PM" ,
        DateTimeFormatter.ofPattern( "MM/dd/uuuu hh:mm a" , Locale.US )
    )
    .atZone(
        ZoneId.systemDefault()   // Better to pass explicitly the time zone known to have been intended for this input. See discussion below.
    )
)

Using java.time

The modern solution uses the java.time classes. Much easier to work with that the terrible old legacy Date , Calendar , etc.

Check if date is one week before from today Java

Did you intend to work with just the dates, and ignore the time-of-day? I will assume not, as your inputs have a time-of-day.

Get current moment in UTC.

Instant instant = Instant.now() ;  // Current moment in UTC.

Adjust into the time zone implied as the context for you date-time input strings. Apply a ZoneId to get a ZonedDateTime object.

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( "Africa/Tunis" ) ;      // Replace with the zone you know to have been intended for the input strings.
ZonedDateTime zdtNow = instant.atZone( z ) ;  // Adjust from UTC to a time zone.

Subtract a week, a requirement you stated in the Question.

ZonedDateTime zdtWeekAgo = zdtNow.minusWeeks( 1 ) ; // Accounts for anomalies such as Daylight Saving Time (DST).

Parse your input strings as LocalDateTime objects because they lack any indicator of time zone or offset-from-UTC.

Tips: If at all possible, change those inputs to include their time zone. And change their formats to use the standard ISO 8601 formats rather than custom format.

DateTimeFormatter f = DateTimeFormatter.ofPattern( "MM/dd/uuuu hh:mm a" , Locale.US ) ;
LocalDateTime ldt = LocalDateTime.parse( "09/12/2017 08:09 PM" , f ) ;

Assign the time zone you know to have been intended for those input strings.

ZonedDateTime zdt = ldt.atZone( z ) ;

Compare.

boolean moreThanWeekOld = zdt.isBefore( zdtWeekAgo ) ;

---

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 4

Java 8 independent

How about doing it in simple way ie get time from two dates and find the difference . Convert this difference into days to get difference between two dates in days . Below is working code :

Date formattedToday = new Date();
Date formattedExpired = new Date("06/12/2018 08:09 PM");

int diffInDays = (int)( (formattedToday.getTime() - formattedExpired.getTime())
        / (1000 * 60 * 60 * 24) );

if (diffInDays > 7) 
Log.i("Expiration Status : ", "Expired");

It will give you difference between two dates in days and it can be negative if expiry date is of future and positive if expiry date is of past.