How to compare to dates

Compare Two Dates in JavaScript

Introduction

That is, we compare if a date is after or before another, if the date is today, how many days there are between dates, etc.

In this article, we’ll take a look at how to compare two dates in JavaScript, helping us deduce whether a date is before or after another.

The Date Object in JavaScript

Web developers commonly use external packages (like Moment.js) to handle date-time operations. But, as the modern web evolved, JavaScript introduced a new object constructor called Date to handle date-time operations.

This means that you don’t need an external library to perform rudimentary checks and operations, which makes it easier to perform these things in Vanilla JS.

Unix time is measured as the number of seconds elapsed since the Unix epoch (00:00:00 UTC 1 January 1970), which is a completely arbitrary date.

Even though this implementation seems a bit simplistic, the addition of the Date class was quite a big improvement, since there was finally a level of abstraction between developers and raw dates.

Now, let’s look at different ways to compare two dates using Date objects.

Comparing Two Dates in JavaScript

We can use comparison operators like and > two compare two Date objects, and under the hood, their time counters are effectively compared. You’re effectively comparing two integer counters:

This results in:

As we can see, comparing dates just boils down to converting the provided strings into Date objects and comparing them with an appropriate comparison operator.

Note: Equality operators ( == and === ) don’t work with Date objects, so we don’t explicitly check if they’re the same.

Another way to compare two dates is by using the built-in getTime() method.

Note: With this approach, you can use equality operators!

Let’s take a look at an example:

This results in:

Free eBook: Git Essentials

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

For example, this code:

Would result in:

Since we’re just comparing the date, without the year in mind.

Conclusion

In this article, we’ve briefly gone over how JavaScript handles dates using Date objects. Then, we’ve covered how to compare dates in JavaScript, keeping some useful methods in mind.

How to compare dates in Java

December 25, 2019 • Atta ✨

It is often required to compare dates while working in Java or any other programming language. Date comparison is a simple yet confusing (at least for me) task that is worth the effort to learn given that the number of times you’d be comparing different dates in Java.

In this article, you’ll learn how to compare two dates in Java using both Java 8 new date and time API as well as the legacy Date and Calendar API.

Java 8 Date & Time API

Java 8 introduced a brand new date and time API (classes in java.time.* package) to fix the flaws in the old API. The new API is thread-safe, easier-to-use, and provides a bunch of utility methods to perform different date and time tasks.

Let us look at the examples that use the above methods to compare new date and time API instances.

Comparing LocalDate Instances

The following example demonstrates how you can parse two strings to instances of LocalDate and then compare them to see if they before, equal or after to each other:

The above code will print the following on the console:

Let us look at another example that uses compareTo() to compare two instances of LocalDate :

You will see the following output if you execute the above code:

Comparing LocalTime Instances

A LocalTime represents a time without date in ISO-8601 format (HH:mm:ss). Here is an example that shows how to compare two instances of LocalTime in Java 8 and higher:

The above code will output the following:

You can also compare two instances of LocalTime by using compareTo() method just like LocalDate :

Here is how the output looks like now:

Comparing LocalDateTime Instances

The above code prints the following on the console:

If you execute the above code snippet, you should see the following output:

Comparing ZonedDateTime Instances

A ZonedDateTime represents a date and time with a timezone in ISO-8601 format (e.g 2015-05-15T10:15:30+01:00[Europe/Paris]). It is basically used to deal with timezone specific dates and times.

The following example demonstrates how you can compare two instances of ZonedDateTime in Java:

You should see the following output for the above code snippet:

ZonedDateTime also provides compareTo() method to perform the comparison between two of its instances:

You should see the following output:

Comparing OffsetDateTime Instances

An instance of OffsetDateTime represents a date and time with an offset from UTC/Greenwich in the ISO-8601 format (e.g. 2018-06-30T23:15:30+03:30).

Let us look at the below example that shows how you can compare two instances of OffsetDateTime :

Here is the output of the above code snippet:

Similarly you can use compareTo() to compare two instances of OffsetDateTime as shown below:

The above code will output the following:

Comparing Instant Instances

An Instant represents a specific moment on the timeline in UTC. Here is how you can compare two instances of Instant :

Here is the output of the above code snippet:

Two instances of Instant can also be compared by using compareTo() as shown below:

Here is the output when we use compareTo() to compare Instant objects:

Look at Introduction to Java 8 Date and Time API tutorial for more new date and time API examples.

Old Date and Calendar API

Both Date and Calendar classes provide the following method for date comparison.

compareTo() Method

The compareTo() method is used to compares two dates for ordering. It returns 0 if both dates are equal. Otherwise, a positive value if this date is greater than the specified date, and negative if less.

The following example shows how you can compare two instances of Date by using compareTo() method:

The above code will output something like the following:

Similarly, you can also compare two instances of Calendar by using compareTo() method as shown below:

Here is an example that uses the above methods to compare two instances of Date :

If you execute the above code snippet, you’d see the following output:

Finally, in the end, let us look at an example that demonstrates how to compare two instances of Calendar API:

Summary

Date comparison is an essential task that you should know how to do it while working in Java. In this article, we have covered multiple ways to compare dates originating from different APIs in Java. We started with Java 8 new date and time API and discussed how to compare dates with or without time and timezones. In the end, we also looked at comparing dates using the legacy Date and Calendar API.

The new date and time API introduced in Java 8 provides a broad range of classes that have simplified working in dates and times. These classes are thread-safe, easier-to-use, and come with plenty of utility methods for performing various operations.

✌️ Like this article? Follow me on Twitter and LinkedIn. You can also subscribe to RSS Feed.

How to compare dates in Java? [duplicate]

How do I compare dates in between in Java?

date1 is 22-02-2010
date2 is 07-04-2010 today
date3 is 25-12-2010

date3 is always greater than date1 and date2 is always today. How do I verify if today’s date is in between date1 and date 3?

11 Answers 11

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Date has before and after methods and can be compared to each other as follows:

For an inclusive comparison:

You could also give Joda-Time a go, but note that:

Joda-Time is the de facto standard date and time library for Java prior to Java SE 8. Users are now asked to migrate to java.time (JSR-310).

Back-ports are available for Java 6 and 7 as well as Android.

Following are most common way of comparing dates (my preference is Approach 1):

Approach 2: Date.compareTo()

Or, better, if you add the ThreeTen-Extra library to your project.

Half-open approach, where beginning is inclusive while ending is exclusive.

Bad Choice of Format

By the way, that is a bad choice of format for a text representation of a date or date-time value. Whenever possible, stick with the standard ISO 8601 formats. ISO 8601 formats are unambiguous, understandable across human cultures, and are easy to parse by machine.

For a date-only value, the standard format is YYYY-MM-DD. Note how this format has the benefit of being chronological when sorted alphabetically.

LocalDate

The LocalDate class represents a date-only value without time-of-day and without time zone.

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.

DateTimeFormatter

As your input strings are non-standard format, we must define a formatting pattern to match.

Use that to parse the input strings.

In date-time work, usually best to define a span of time by the Half-Open approach where the beginning is inclusive while the ending is exclusive. So we want to know if today is the same or later than the start and also before the stop. A briefer way of saying “is the same or later than the start” is “not before the start”.

See the Answer by gstackoverflow showing the list of comparison methods you can call.

About java.time

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

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. Hibernate 5 & JPA 2.2 support java.time.

Where to obtain the java.time classes?

UPDATE: This “Joda-Time” section below is left intact as history. The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

Joda-Time

Other answers are correct with regard to the bundled java.util.Date and java.util.Calendar classes. But those classes are notoriously troublesome. So here’s some example code using the Joda-Time 2.3 library.

Define a formatter describing the input strings…

Use formatter to parse the strings into LocalDate objects…

Dump to console…

So see if the second is between the other two (exclusively, meaning not equal to either endpoint)…

Working With Spans Of Time

If you are working with spans of time, I suggest exploring in Joda-Time the classes: Duration, Interval, and Period. Methods such as overlap and contains make comparisons easy.

For text representations, look at the ISO 8601 standard’s:

Joda-Time classes can work with strings in both those formats, both as input (parsing) and output (generating strings).

Joda-Time performs comparisons using the Half-Open approach where the beginning of the span is inclusive while the ending is exclusive. This approach is a wise one for handling spans of time. Search StackOverflow for more info.

Compare two dates in Java

I need to compare two dates in java. I am using the code like this:

This is not working. The content of the variables is the following:

How can I resolve this?

13 Answers 13

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Date equality depends on the two dates being equal to the millisecond. Creating a new Date object using new Date() will never equal a date created in the past. Joda Time’s APIs simplify working with dates; however, using the Java’s SDK alone:

JodaTime can be downloaded from here.

It’s not clear to me what you want, but I’ll mention that the Date class also has a compareTo method, which can be used to determine with one call if two Date objects are equal or (if they aren’t equal) which occurs sooner. This allows you to do something like:

The easiest way to compare two dates is converting them to numeric value (like unix timestamp).

You can use Date.getTime() method that return the unix time.

java.time

In Java 8 there is no need to use Joda-Time as it comes with a similar new API in the java.time package. Use the LocalDate class.

You can ask for the span of time between the dates with Period class.

LocalDate is comparable using equals and compareTo as it holds no information about Time and Timezone.

About java.time

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.

How to compare two dates in JavaScript

Find out how to compare two dates in JavaScript, with and without time, with and without libraries like date-fns.

In this post we will be covering how to compare two dates in JavaScript with as little technical jargon as possible so you will have everything you need right here without having to look any further!

There are many different scenarios to comparing dates in JS, such as if you want to compare whole dates, days, hours, months, years, with or without time, the current date, and so on.

On top of equality comparisons, we will also probably want to be able to perform greater than or equal comparisons with dates in JavaScript as well.

As well as our own comparisons, there are many libraries out there as well.

In this post we will be covering all of these topics!

Comparing two JavaScript dates

Firstly to compare two dates in JavaScript, let’s take a look at how we can compare two dates to see if they are equal.

In JavaScript, it is well known that we cannot compare two different objects, even if they are the same because they are different instances which means they will always fail when comparing them.

With this in mind, we can’t just compare two Date Objects with a comparison operator because they are also objects.

Instead we need to get the value from the Date objects before we can compare them and there are a few different ways to do this.

The main option we can use when comparing dates is to use Date.prototype.getTime(). The Date.prototype.getTime() method will return the time in milliseconds since the Unix epoch.

What this means is we get a quantifiable number that we can use to compare, or even use greater than or equal to operators with.

Here is an example of how this will look:

Compare two dates in JavaScript by days, months, or years in JavaScript (without time)

So, what do I mean here by comparing dates by days, months, or years without time?

Well whilst in most cases a simple comparison will suffice, we might also need to check if two dates are the same day, month or year without time.

When I say comparing dates without time here, I mean literally without the time part of a date, which just means we need to look at years, months and days, and not hours, minutes, seconds, and milliseconds.

For example, we might want to check if a Date is before, on, or after a certain day, and if we use a comparison using milliseconds like above whilst still accounting for the time part of the date, we would be checking the milliseconds of the hours, minutes, seconds, and milliseconds as well which means we won’t be comparing only the days.

This means that we would potentially have failed comparisons that should have passed because time is too granular for what we need when comparing days.

To solve this problem there are many solutions so it is very much a case of selecting which one you prefer or suits your situation the best.

One of the simplest solutions, and the one we will cover in this post, to understand is to once again use the getTime method just like before so that we are still working with a single number, but before we perform the comparison, we can first set the hours, minutes, seconds, and milliseconds to 0 on all dates to remove the time from the dates so that we create an even playing field so we can compare only what we need.

The best way to do this is if we create a helper function, let’s take a look at how we can compare days like this:

In this helper function we create two new dates and we only set the years, months and days, and not the hours, minutes, seconds and milliseconds.

By doing that we can compare only the days without the time. To compare seconds, hours, months or years it is the exact same principle but you just need to pass in whichever is relevant into the Date constructor for your needs.

With months for example, you would only need to pass in years and months, whereas for years you would only need to pass in years, but for hours you would need to pass in the years, months, days and hours.

Whilst this is fine in this case, it would be better to split this up into multiple, more verbose, helper functions to avoid confusion, we can do this like so:

By splitting these out into individual functions it makes it easier to read, use and maintain in the future and we now get the added benefit of dealing with booleans rather than numbers.

How can we improve comparing two dates in JavaScript with a library

These methods of comparing dates will work for the current time, preset times and times in any format (e.g mm/dd/yyyy) as long as they have been created as a native JavaScript Date.

This is great if you are wanting your comparisons to be as lightweight as possible, but the problem is that it can be pretty time consuming to have to write out and test all the helper methods you might need to compare and work with JavaScript dates.

This is where a good, lightweight library could save you a lot of time, and headaches.

One of the best JavaScript date libraries out there for this problem is called date-fns.

Unlike something like moment.js (which is to be avoided), date-fns uses the native JavaScript Date object so you don’t have to worry about having a large overhead in the size of the library.

Also, date-fns is simply a collection of utilities and helper methods to make using native JavaScript Date objects much easier, similar to what we did above.

If you want to read their documentation to find out more helper methods you can find it here.

Here are a few examples using date-fns to compare two dates in JavaScript:

Summary

There we have how to compare two dates in JavaScript, if you want more like this be sure to check out some of my other posts!

I hope this post has helped, but before you go, make sure you try my fun interactive quiz to see if you are a novice, intermediate, or expert React engineer.

Are you a novice, intermediate or expert react engineer?

Some graphics used on this post were made using icons from flaticon.

Latest Posts

This post will cover everything you need to know about React Fragments in a clear and concise way and will be the ultimate resource for any React Fragment related query.

How to wait for all promises to resolve in JavaScript

This post will cover how to wait for all promises to resolve in JavaScript rather than having to take them one by one when you have multiple promises that need resolving.

Everything you need to know about React Keys

In this guide you will discover everything you need to know about React Keys to be able to use them properly in any React app along with the ins and outs.