Differences between Date, DateTime and Calendar in Java 7

Type objects Datein Java are used to represent a specific instant in time. It also allows converting and parsing dates however the methods that provided this are now deprecated .

Taking its place is the class Calendarfor date arithmetic and conversions, this class also provides the ability to work with Localesand represent dates in different languages ​​or specific calendar types.

Converting objects Dateto Calendaris simple:

Date d = new Date();  // Crea el objeto Date
Calendar calendar = Calendar.getInstance(); // Obtiene una instancia de Calendar
calendar.setTime(date); // Asigna la fecha al Calendar

Once you have an instance of Calendaryou can get information about the date in the following way:

int year        = calendar.get(Calendar.YEAR);
int month       = calendar.get(Calendar.MONTH);
int weekOfMonth = calendar.get(Calendar.WEEK_OF_MONTH);

One thing to keep in mind is that the months are considered integers from 0 to 11. In the documentation you can find all the available fields that you can consult.

If you have an instance of Calendarand want to convert to date:

Calendar calendar = Calendar.getInstance();
Date date =  calendar.getTime();

For parsing and formatting dates, it is recommended to use the class DateFormator a subclass such as SimpleDateFormat, for example:

SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
String fecha = sdf.format(new Date()); 
System.out.println(fecha); // 27/01/2016

My suggestion is that you store your dates as objects Datebecause they are easier objects to generate and if you need any conversions or operations like adding 5 months to a date use Calendarthen return to the Date.

Lastly DateTimeis not a data type in Java SE, it exists as part of a library called Joda Time , and it offers a variety of additional methods for operating on dates.

From the documentation of java.util.Date(translated):

The class Daterepresents a specific instant in time, accurate to the millisecond.

While java.util.Calendar(translated, emphasis mine):

The class Calendaris an abstract class that provides methods to convert between a specific instant in time and a set of calendar fields such as YEAR (year), MONTH (month), DAY_OF_MONTH (day of month), HOUR (hour) and so on, and to manipulate calendar fields, such as getting next week's date.

The biggest problem here in the design of the class Dateis that it is mutable, when it should have been immutable and the operation on dates such as increasing (or decreasing) days, hours, seconds, years, etc, and the generation of Dates should be through Calendar. At least this is the way I usually work to avoid problems handling the Date. In Java 8 this was solved by implementing a new internal framework for handling dates and times called Java 8 Date and Time and the classes can be found under the package java.time(your question is based on Java 7, so I only mention this part of Java 8, I will not delve further into this point).

To use Calendar, I recommend you always initialize it as follows:

Calendar calendar = Calendar.getInstance();

Since there is more than one implementation of Calendar, with the best known (and used) GregorianCalendarbeing , but there are also BuddhistCalendarand JapaneseImperialCalendar(at least from Open JDK code). The method Calendar#getInstancedelegates the creation of the calendar to the method createCalendarwhich for Java 8 is implemented as follows (reviewing the HotSpot source code):

private static Calendar createCalendar(TimeZone zone,
                                       Locale aLocale)
{
    CalendarProvider provider =
        LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                             .getCalendarProvider();
    if (provider != null) {
        try {
            return provider.getInstance(zone, aLocale);
        } catch (IllegalArgumentException iae) {
            // fall back to the default instantiation
        }
    }

    Calendar cal = null;

    if (aLocale.hasExtensions()) {
        String caltype = aLocale.getUnicodeLocaleType("ca");
        if (caltype != null) {
            switch (caltype) {
            case "buddhist":
            cal = new BuddhistCalendar(zone, aLocale);
                break;
            case "japanese":
                cal = new JapaneseImperialCalendar(zone, aLocale);
                break;
            case "gregory":
                cal = new GregorianCalendar(zone, aLocale);
                break;
            }
        }
    }
    if (cal == null) {
        // If no known calendar type is explicitly specified,
        // perform the traditional way to create a Calendar:
        // create a BuddhistCalendar for th_TH locale,
        // a JapaneseImperialCalendar for ja_JP_JP locale, or
        // a GregorianCalendar for any other locales.
        // NOTE: The language, country and variant strings are interned.
        if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
            cal = new BuddhistCalendar(zone, aLocale);
        } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                   && aLocale.getCountry() == "JP") {
            cal = new JapaneseImperialCalendar(zone, aLocale);
        } else {
            cal = new GregorianCalendar(zone, aLocale);
        }
    }
    return cal;
}

I always recommend working with Calendarbecause it is considered good practice to work with abstract classes and interfaces whenever possible over working with the implementation directly. This is covered here: https://stackoverflow.com/q/383947/1065197

I don't know of any class DateTimedeclared in JDK 7. Perhaps you are referring to the Joda Timeorg.joda.time.DateTime library class (curious name in Spanish), which emerged as a solution to avoid working with the fact that it is mutable. is immutable and operations you perform on a will actually create a new instance of instead of modifying the current instance.DateDateTimeDateTimeDateTime

If you want to know which class you should use in your projects, I would give you the following recommendations:

• For your entities, declare the type fields Date(make sure they are from the package java.util).
• To perform operations on Datehow to add or remove time, there are 2 options:
  • Create an object of type Calendar, set its time from an instance of Datevia Calendar#setTime, perform the necessary operations, and get the Dateof Calendarvia Calendar#getTime.
  • Similar procedure as described above, but using DateTimede Joda.
• If you want to represent a date and time in a textual way, I recommend you to use SimpleDateFormat#format(Date)(eye, receive Dateand not Calendar) and avoid using the Date#getXyz. You could also use Calendar#get(Calendar.<campo>)but the code would be very verbose (I don't know a translation of this).

Why not directly declare the use of DateTimein the fields of your entities? Well, because there are frameworks that do not support direct conversion unless you implement particular converters for it. Some examples: Hibernate ¹ , JSF, Spring, etc.

¹ Hibernate 5 now offers support for the Java 8 Date Time library. I guess the frameworks will slowly go that way too at some point.