DateTimeTools (MyTISM API Documentation)

java.lang.Object
- de.ipcon.tools.date.DateTimeTools

```
public class DateTimeTools
extends java.lang.Object
```
Provides static tool methods for Date and related objects.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`DATEFORMAT_PATTERN`
`static java.math.BigDecimal`	`HOURS_PER_DAY`
`static java.math.BigDecimal`	`MILLISECONDS_PER_DAY`
`static java.math.BigDecimal`	`MILLISECONDS_PER_HOUR`
`static java.math.BigDecimal`	`MILLISECONDS_PER_MINUTE`
`static java.math.BigDecimal`	`MILLISECONDS_PER_SECOND`
`static java.math.BigDecimal`	`MINUTES_PER_DAY`
`static java.math.BigDecimal`	`MINUTES_PER_HOUR`
`static java.math.BigDecimal`	`SECONDS_PER_DAY`
`static java.math.BigDecimal`	`SECONDS_PER_HOUR`
`static java.math.BigDecimal`	`SECONDS_PER_MINUTE`
`static java.lang.String`	`STRIP_DATE`
`static java.lang.String`	`STRIP_DAYS`
`static java.lang.String`	`STRIP_HOURS`
`static java.lang.String`	`STRIP_MILLISECONDS`
`static java.lang.String`	`STRIP_MINUTES`
`static java.lang.String`	`STRIP_MONTHS`
`static java.lang.String`	`STRIP_SECONDS`
`static java.lang.String`	`STRIP_TIME`
`static java.lang.String`	`STRIP_YEARS`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static java.util.Date`	`addDay(java.util.Date d)` add 1 day to a given date simply a wrapper method for addToDate(d, Calendar.DAY_OF_MONTH, 1)
`static java.util.Date`	`addDays(java.util.Date d, int days)` adds a given number of days to a given date simply a wrapper method for addToDate(d, Calendar.DAY_OF_MONTH, days)
`static java.util.Date`	`addHour(java.util.Date d)` add 1 hour to a given date simply a wrapper method for addToDate(d, Calendar.HOUR, 1)
`static java.util.Date`	`addHours(java.util.Date d, int hours)` adds a given number of hours to a given date simply a wrapper method for addToDate(d, Calendar.HOUR, hours)
`static java.util.Date`	`addMillisecond(java.util.Date d)` add 1 millisecond to a given date simply a wrapper method for addToDate(d, Calendar.MILLISECOND, 1)
`static java.util.Date`	`addMilliseconds(java.util.Date d, int ms)` adds a given number of milliseconds to a given date simply a wrapper method for addToDate(d, Calendar.MILLISECOND, ms)
`static java.util.Date`	`addMinute(java.util.Date d)` add 1 minute to a given date simply a wrapper method for addToDate(d, Calendar.MINUTE, 1)
`static java.util.Date`	`addMinutes(java.util.Date d, int minutes)` adds a given number of minutes to a given date simply a wrapper method for addToDate(d, Calendar.MINUTE, minutes)
`static java.util.Date`	`addMonth(java.util.Date d)` add 1 month to a given date simply a wrapper method for addToDate(d, Calendar.MONTH, 1)
`static java.util.Date`	`addMonths(java.util.Date d, int months)` adds a given number of months to a given date simply a wrapper method for addToDate(d, Calendar.MONTH, months)
`static java.util.Date`	`addSecond(java.util.Date d)` add 1 second to a given date simply a wrapper method for addToDate(d, Calendar.SECOND, 1)
`static java.util.Date`	`addSeconds(java.util.Date d, int seconds)` adds a given number of seconds to a given date simply a wrapper method for addToDate(d, Calendar.SECOND, seconds)
`static java.util.Date`	`addToDate(java.util.Date d, int arg0, int toAdd)` adds a given number of Date-Parts (Seconds, Minutes, Days, Years,...) to a given date the type to add (arg0) must be a field of java.util.Calendar, i.e.: Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR, ...
`static java.util.Date`	`addToDate(java.util.Date d, java.util.concurrent.TimeUnit unit, int toAdd)` adds the given amount of the given TimeUnit to the given date values given with unit microseconds or nanoseconds are being converted to milliseconds first
`static java.util.Date`	`addWeek(java.util.Date d)` add 1 week to a given date simply a wrapper method for addToDate(d, Calendar.WEEK_OF_YEAR, 1)
`static java.util.Date`	`addWeeks(java.util.Date d, int weeks)` adds a given number of weeks to a given date simply a wrapper method for addToDate(d, Calendar.WEEK_OF_YEAR, weeks)
`static java.util.Date`	`addYear(java.util.Date d)` add 1 year to a given date simply a wrapper method for addToDate(d, Calendar.YEAR, 1)
`static java.util.Date`	`addYears(java.util.Date d, int years)` adds a given number of years to a given date simply a wrapper method for addToDate(d, Calendar.YEAR, years)
`static java.util.Date`	`adjustTimeToMinimum(java.util.Date _date1, java.util.Date _date2)`
`static void`	`checkTimespan(TimespanI _ts)` Checks the given `TimespanI` for errors.
`static int`	`countDays(java.util.Date d1, java.util.Date d2)` Counts the days between the dates, including the first, and including the last, ignoring time.
`static int`	`countDays(TimespanI ts)` Counts the days covered by the passed TimespanI, ignoring time.
`static long`	`countDaysInYears(int yearFrom, int yearTo)` Returns the number of days in a given year-range, regarding if there are leap-years.
`static long`	`coveredTimespanInFullMinutes(java.util.Date d1, java.util.Date d2)` Returns the number of minutes that the passed Date objects cover, rounded down.
`static int`	`coveredTimespanToDays(java.util.Calendar c1, java.util.Calendar c2)` Returns the timespan between the passed Calendar objects, converted to days, default rounded up.
`static int`	`coveredTimespanToDays(java.util.Calendar c1, java.util.Calendar c2, boolean roundUp)`
`static int`	`coveredTimespanToDays(java.util.Date d1, java.util.Date d2)` Returns the timespan between the passed Date objects, converted to days, default rounded up.
`static int`	`coveredTimespanToDays(java.util.Date d1, java.util.Date d2, boolean roundUp)`
`static int`	`coveredTimespanToDays(TimespanI ts)` Returns the timespan between the passed Date objects, converted to days, default rounded up.
`static int`	`coveredTimespanToDays(TimespanI ts, boolean roundUp)`
`static java.util.Calendar`	`createCalendar()` Creates a new java.util.Calendar from the given Date object.
`static java.util.Calendar`	`createCalendar(java.util.Date _d)`
`static java.util.Calendar`	`createCalendar(long _millis)` Creates a new java.util.Calendar represeting the passed time since epoch in millis.
`static javax.xml.datatype.Duration`	`datesToDurationMillis(java.util.Date from, java.util.Date till)` determines and returns the relevant part of a given timespan, i.e. the part which lies within a given global time-frame
`static java.util.Date`	`getDate(java.lang.String _str)` Deprecated. use L10n.parseDate instead!
`static java.util.List<java.util.Date>`	`getDateObjects(java.util.Date from, java.util.Date till)` Returns a List of `Date` objects for a period between from and till parameters.
`static java.util.Calendar`	`getDateWithoutTime(java.util.Calendar c)` Returns a copy of the passed Calendar, stripped of its time
`static int`	`getDay(java.util.Date d)` Returns an int with the day of the given date, -1 is the given date is null. 1 based.
`static int`	`getDaysPerMonth(java.util.Date d)` returns the number of days of the month of the given date
`static int`	`getDaysPerMonth(int year, int month)` returns the number of days of the given month in the given year
`static int`	`getDaysPerYear(int year)` Returns the number of days in a given year, regarding if it is a leap-year or not.
`static java.util.Date`	`getFirstDayOfCurrentYear()` Returns a Date object representing the first day of the current year, stripped of time.
`static java.util.Date`	`getFirstDayOfMonth(java.util.Date d)` Returns a Date object representing the first day of the month of the given date.
`static java.util.Date`	`getFirstDayOfMonth(java.util.Date d, boolean stripTime)`
`static java.util.Date`	`getFirstDayOfNextMonth(java.util.Date d)` Returns a Date object representing the first day of the month after the given date.
`static java.util.Date`	`getFirstDayOfNextMonth(java.util.Date d, boolean stripTime)`
`static java.util.Date`	`getFirstDayOfPreviousMonth(java.util.Date d)` Returns a Date object representing the first day of the month before the given date.
`static java.util.Date`	`getFirstDayOfPreviousMonth(java.util.Date d, boolean stripTime)`
`static java.util.Date`	`getFirstDayOfYear(java.util.Date d)` Returns a Date object representing the first day of the year of the passed Date, stripped of time.
`static java.util.Date`	`getFirstDayOfYear(int year)` Returns a Date object representing the first day of the passed year, stripped of time.
`static java.util.List<java.lang.String>`	`getFormatsWithExamples(java.util.Collection<java.lang.String> formats)` Returns a list of date format strings along with examples of the current date formatted according to each of these formats.
`static java.math.BigDecimal`	`getFractionOfMonth(java.util.Date startDayInMonth, java.util.Date endDayInMonth)` Calculates and returns the fraction of a month covered by the given Dates, based on number of days covered.
`static java.math.BigDecimal`	`getFractionOfMonth(java.util.Date startDayInMonth, java.util.Date endDayInMonth, int precision)`
`static java.lang.String`	`getHourOfDay(java.util.Date _date)`
`static int`	`getHourOfDayAsInt(java.util.Date d)` Returns an int with the hour of day of the given date, -1 if the given date is null
`static int`	`getHoursPerYear(int year)` Returns the number of hours in a given year, regarding if it is a leap-year or not.
`static boolean`	`getIstZeitumstellungSommerNachWinter(java.util.Date d)`
`static boolean`	`getIstZeitumstellungWinterNachSommer(java.util.Date d)`
`static java.util.Date`	`getLastDayOfMonth(java.util.Date d)` Returns a Date being the last day of month and year of the given date.
`static java.util.Date`	`getLastDayOfMonth(java.util.Date d, boolean stripTime)`
`static java.util.Date`	`getLastDayOfNextMonth(java.util.Date d)` Returns a Date object representing the last day of the month after the given date.
`static java.util.Date`	`getLastDayOfNextMonth(java.util.Date d, boolean stripTime)`
`static java.util.Date`	`getLastDayOfPreviousMonth(java.util.Date d)` Returns a Date object representing the last day of the month before the given date.
`static java.util.Date`	`getLastDayOfPreviousMonth(java.util.Date d, boolean stripTime)`
`static java.util.Date`	`getLastDayOfYear(java.util.Date d)` Returns a Date object representing the last day of the year of the passed date, stripped of time.
`static java.util.Date`	`getLastDayOfYear(int year)` Returns a Date object representing the last day of the year represented by the passed int, stripped of time.
`static int`	`getMinuteAsInt(java.util.Date d)` Returns an int with the minute of the given date, -1 if the given date is null
`static int`	`getMonth(java.util.Date d)` Returns an int with the month of the given date, -1 if the given date is null.
`static int`	`getMonth(java.util.Date d, boolean oneBased)`
`static java.util.Collection<java.lang.String>`	`getMonthsList()` Returns an ordered list of String month representations with 2 digits for usage e.g. in a ComboBox.
`static java.util.Collection<java.lang.String>`	`getMonthsList(boolean reversed)`
`static java.util.Collection<java.lang.String>`	`getMonthsList(boolean reversed, java.util.Date stopMonth)`
`static java.util.Date`	`getNextMatchingDate(java.lang.String _cronDef)` Evaluates a cron definition and returns the next date the definition matches on.
`static java.util.Date`	`getNextMatchingDate(java.lang.String _cronDef, java.util.Date fromReferenceDate)`
`static java.util.Date`	`getNextMatchingDate(java.lang.String _cronDef, java.util.Date fromReferenceDate, java.util.TimeZone timeZone)`
`static java.lang.Long`	`getNumberOfMillis(java.util.Date d1, java.util.Date d2)` Returns the number of milliseconds that the passed Date objects cover
`static int`	`getNumberOfMonths(java.util.Calendar c1, java.util.Calendar c2)` Returns the number of months that the passed Calendar objects cover, rounded up
`static int`	`getNumberOfMonths(java.util.Date from, java.util.Date till)` Returns the number of months that the passed Date objects cover, rounded up
`static int`	`getNumberOfTouchedYears(java.util.Date start, java.util.Date stop)` Returns the number of years the passed dates touch.
`static java.lang.String`	`getQuartal(java.util.Date _d)` Returns String object with quarter and year of given date, empty string if date is null
`static DateContainer`	`getRelevantTimespan(java.util.Date _globalFrom, java.util.Date _globalTo, java.util.Date _localFrom, java.util.Date _localTo)` determines and returns the relevant part of a given timespan, i.e. the part which lies within a given global time-frame
`static java.util.Calendar`	`getTimeWithoutDate(java.util.Calendar c)` Returns a copy of the passed Calendar, stripped of its date
`static long`	`getTimeZoneChangesIn1Day(java.util.Date d)` Uses the java time framework to decide if there is a change of time offset compared to UTC, i.e. from summer to winter time on that date or vice versa.
`static long`	`getTimeZoneChangesIn1Day(java.time.ZonedDateTime zdtstart)` Method checks if there is a time zone change between the provided datetime and the datetime 1 day later.
`static java.lang.String`	`getWeekOfYear(java.util.Date _date)`
`static java.lang.String`	`getYear(java.util.Date _date)`
`static int`	`getYearAsInt(java.util.Date d)` Returns an int with the year of the given date, -1 if the given date is null
`static boolean`	`isAfterOrSameDate(java.util.Calendar cal1, java.util.Calendar cal2)` Returns true if the passed Calendars are equal or the first date is temporally after the second one.
`static boolean`	`isAfterOrSameDate(java.util.Date date1, java.util.Date date2)` Returns true if the passed dates are equal or the first date is temporally after the second one.
`static boolean`	`isAfterOrSameDay(java.util.Date dateToCheck, java.util.Date anchorDate)` Returns true if the passed dates are on the same day or the first date is temporally after the anchor date.
`static boolean`	`isAfterOrSameDay(java.util.Date dateToCheck, java.util.Date anchorDate, boolean ignoreTime)`
`static boolean`	`isBeforeOrSameDate(java.util.Calendar cal1, java.util.Calendar cal2)` Returns true if the passed Calendars are equal or the first date is temporally before the second one.
`static boolean`	`isBeforeOrSameDate(java.util.Date date1, java.util.Date date2)` Returns true if the passed dates are equal or the first date is temporally before the second one.
`static boolean`	`isBeforeOrSameDay(java.util.Date dateToCheck, java.util.Date anchorDate)` Returns true if the passed dates are on the same day or the first date is temporally before the anchor date.
`static boolean`	`isBeforeOrSameDay(java.util.Date dateToCheck, java.util.Date anchorDate, boolean ignoreTime)`
`static boolean`	`isFirstDayOfMonth(java.util.Date d)` Returns true if the passed date is on the first day of the respective month
`static boolean`	`isFirstDayOfYear(java.util.Date d)` Returns true if the passed date is the first day of the year
`static boolean`	`isLastDayOfMonth(java.util.Calendar cal)` Returns true if the passed Calendar represents the last day of the respective month
`static boolean`	`isLastDayOfMonth(java.util.Date d)` Returns true if the passed date is on the last day of the respective month
`static boolean`	`isLastDayOfYear(java.util.Date d)` Returns true if the passed date represents the last day of its year
`static boolean`	`isMonth(java.util.Date d, int month)` Returns `true` if the passed date has the specified month.
`static boolean`	`isNextDay(java.util.Date nextDay, java.util.Date day)` Returns `true` if the "nextDay" (1st argument) is the same day as the next day after the "day" (2nd argument).
`static boolean`	`isPreviousDay(java.util.Date previousDay, java.util.Date day)` Returns `true` if the "previousDay" (1st argument) is the same day as the previous day before the "day" (2nd argument).
`static boolean`	`isSameDay(java.util.Date date1, java.util.Date date2)` Returns `true` if the passed dates are on the same day or both dates are null.
`static boolean`	`isSameDayOfWeek(java.util.Date d1, java.util.Date d2)` Returns `true` if the passed dates have the same day of the week.
`static boolean`	`isSameMonth(java.util.Date date1, java.util.Date date2)` Returns `true` if the passed dates are in the same month.
`static boolean`	`isSameYear(java.util.Date date1, java.util.Date date2)` Returns `true` if the passed dates are in the same year or both dates are null.
`static boolean`	`isSaturday(java.util.Date d)` Returns true if the passed date is a saturday.
`static boolean`	`isSpecificDay(java.util.Date d, int day)` Returns true if the passed date is a given day.
`static boolean`	`isSunday(java.util.Date d)` Returns true if the passed date is a sunday.
`static boolean`	`isWeekend(java.util.Date d)` Returns true if the passed date is a weekend day.
`static java.util.Date`	`joinDates(java.util.Date _date, java.util.Date _time)` Returns a Date object with the date of the 1st passed object and the time of the 2nd passed object
`static boolean`	`liesInInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd)` Checks if the given `candidate` lies within the given `dateStart` and `dateEnd`.
`static boolean`	`liesInInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate, boolean excludingLeft)`
`static boolean`	`liesInInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate, boolean excludingLeft, boolean excludingRight)`
`static boolean`	`liesInInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate, boolean excludingLeft, boolean excludingRight, boolean stripTime)`
`static boolean`	`liesInInterval(java.util.Date candidate, TimespanI ts)` Checks if the given `Date` lies within the given `TimespanI`.
`static boolean`	`liesInInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static boolean`	`liesInLeftOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd)` wrapper for liesInInterval. excludes dateStart.
`static boolean`	`liesInLeftOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInLeftOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static boolean`	`liesInLeftOpenInterval(java.util.Date candidate, TimespanI ts)` wrapper for liesInInterval with a Timespan. excludes the start date of the timespan.
`static boolean`	`liesInLeftOpenInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInLeftOpenInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static boolean`	`liesInOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd)` wrapper for liesInInterval. excludes dateStart and dateEnd.
`static boolean`	`liesInOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static boolean`	`liesInOpenInterval(java.util.Date candidate, TimespanI ts)` wrapper for liesInInterval with a Timespan. excludes the start and end date of the timespan.
`static boolean`	`liesInOpenInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInOpenInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static boolean`	`liesInRightOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd)` wrapper for liesInInterval. excludes the dateEnd.
`static boolean`	`liesInRightOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInRightOpenInterval(java.util.Date candidate, java.util.Date dateStart, java.util.Date dateEnd, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static boolean`	`liesInRightOpenInterval(java.util.Date candidate, TimespanI ts)` wrapper for liesInInterval with a Timespan. excludes the end date of the timespan.
`static boolean`	`liesInRightOpenInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate)`
`static boolean`	`liesInRightOpenInterval(java.util.Date candidate, TimespanI ts, java.lang.Boolean fallbackForNullCandidate, boolean stripTime)`
`static java.util.Date`	`longToDate(java.lang.Long _l)` constructs a Date-object representing the time expressed by the given value as milliseconds
`static java.util.Calendar`	`maxCalendar(java.util.Calendar _d1, java.util.Calendar _d2)` Returns the later of the dates represented by the given Calendars.
`static java.util.Calendar`	`maxCalendar(java.util.Calendar _d1, java.util.Calendar _d2, boolean _nullMeansInfinity)`
`static java.util.Date`	`maxDate(java.util.Date _d1, java.util.Date _d2)` Returns the later of the given Dates.
`static java.util.Date`	`maxDate(java.util.Date _d1, java.util.Date _d2, boolean _nullMeansInfinity)`
`static java.util.Calendar`	`minCalendar(java.util.Calendar _d1, java.util.Calendar _d2)` Returns the earlier of the dates represented by the given Calendars.
`static java.util.Calendar`	`minCalendar(java.util.Calendar _d1, java.util.Calendar _d2, boolean _nullMeansEpoch)`
`static java.util.Date`	`minDate(java.util.Date _d1, java.util.Date _d2)` Returns the earlier of the given Dates.
`static java.util.Date`	`minDate(java.util.Date _d1, java.util.Date _d2, boolean _nullMeansEpoch)`
`static java.math.BigDecimal`	`minutesToHours(java.math.BigDecimal mins)` Converts a given amount in minutes to hours and returns a BigDecimal.
`static java.math.BigDecimal`	`minutesToHours(java.math.BigDecimal mins, int precision)`
`static java.math.BigDecimal`	`minutesToHours(java.lang.Long mins)` Converts a given amount in minutes to hours and returns a BigDecimal.
`static java.math.BigDecimal`	`minutesToHours(java.lang.Long mins, int precision)`
`static java.math.BigDecimal`	`minutesToSeconds(java.math.BigDecimal mins)` Converts a given amount in minutes to seconds and returns a BigDecimal.
`static java.lang.Long`	`minutesToSeconds(java.lang.Long mins)` Converts a given amount in minutes to seconds and returns a Long.
`static long`	`nanosTo(long nanos, java.util.concurrent.TimeUnit timeUnit)` Converts the passed nano-second value to the passed TimeUnit and returns the full units of the desired kind (no rounding!)
`static javax.xml.datatype.Duration`	`newDuration()` Creates a new `javax.xml.datatype.Duration` from a string representation.
`static javax.xml.datatype.Duration`	`newDuration(int years, int months, int days, int hours, int minutes, int seconds)` Creates a new `javax.xml.datatype.Duration` from a number of years, months, days, hours, minutes, and seconds.
`static javax.xml.datatype.Duration`	`newDuration(java.lang.String s)`
`static javax.xml.datatype.Duration`	`newDurationFromSeconds(int seconds)` Creates a new `javax.xml.datatype.Duration` from a number of seconds.
`static javax.xml.datatype.Duration`	`newNegativeDuration(int years, int months, int days, int hours, int minutes, int seconds)` Creates a new negative `javax.xml.datatype.Duration` from a number of years, months, days, hours, minutes, and seconds.
`static javax.xml.datatype.Duration`	`newNegativeDurationFromSeconds(int seconds)` Creates a new negative `javax.xml.datatype.Duration` from a number of seconds.
`static boolean`	`nullSafeAfter(java.util.Date date1, java.util.Date date2)` Returns true if first date is temporally after the second one.
`static boolean`	`nullSafeBefore(java.util.Date date1, java.util.Date date2)` Returns true if the first date is temporally before the second one.
`static boolean`	`overlap(TimespanI _ts1, TimespanI _ts2)` Deprecated. use the far more comprehensible method TimespanI::overlapsWith instead FIXME (electris)StromPOD->checkForOverlappingStromlieferinfos() is a similar yet different method. if you have a different case than in this function approaches, feel free to copy from there :-) (-> i have tried to merge them, but the matter is too complex for me and the functions vary too much)
`static boolean`	`overlap(TimespanI _ts1, TimespanI _ts2, boolean _strict)`
`static boolean`	`overlaps(TimespanI _ts, TimespanI[] _tss)` Checks if the given `TimespanI` overlaps any of the other given `TimespanI`s.
`static java.util.Date`	`setDayOfMonth(java.util.Date d, int day)` sets the day of the given month to the given day, 1 based the value of the day gets truncated to the limits of the current month
`static java.util.Date`	`setMaxTime(java.util.Date date)`
`static java.util.Date`	`setMonth(java.util.Date d, int month)`
`static java.util.Date`	`setMonth(java.util.Date d, int month, boolean oneBased)`
`static java.util.Date`	`setTime(java.util.Date _date, int _hours, int _minutes, int _seconds, int _ms)` Convenience method to set get a copy of a given `Date` with the time values set to the given time.
`static java.util.Date`	`setYear(java.util.Date d, int y)` Sets the year in the passed Date object to the passed year.
`static java.util.Calendar`	`stripDate(java.util.Calendar c)` Returns the passed Calendar, stripped of its date
`static java.util.Date`	`stripDate(java.util.Date d)` Returns a copy of the passed Date, stripped of its date
`static java.util.Date`	`stripMillis(java.util.Date _d)` Returns a copy of the passed Date, stripped off its milliseconds
`static java.util.Date`	`stripMinutes(java.util.Date _d)` Returns a copy of the passed Date, stripped off its minutes
`static java.util.Date`	`stripSeconds(java.util.Date _d)` Returns a copy of the passed Date, stripped off its seconds
`static java.util.Calendar`	`stripTime(java.util.Calendar c)` Returns the passed Calendar, stripped of its time
`static java.util.Date`	`stripTime(java.util.Date d)` Returns a copy of the passed Date, stripped of its time
`static java.util.Calendar`	`stripX(java.util.Calendar _c, java.lang.String _mode)` Returns the passed Calendar, stripped of calendarparts defined via _mode _mode can have the following values: STRIP_MILLISECONDS STRIP_SECONDS STRIP_MINUTES STRIP_HOURS STRIP_DAYS STRIP_MONTHS STRIP_YEARS STRIP_TIME STRIP_DATE
`static java.util.Date`	`stripX(java.util.Date _d, java.lang.String _mode)` Returns a copy of the passed Date, stripped of dateparts defined via _mode delegates to stripX(_c = Calendar, _mode = String), for that _mode can have the following values: STRIP_MILLISECONDS STRIP_SECONDS STRIP_MINUTES STRIP_HOURS STRIP_DAYS STRIP_MONTHS STRIP_YEARS STRIP_TIME STRIP_DATE FIXME!
`static java.util.Date`	`subtractDay(java.util.Date d)` subtracts 1 day from a given date simply a wrapper method for subtractFromDate(d, Calendar.DAY_OF_MONTH, 1)
`static java.util.Date`	`subtractDays(java.util.Date d, int days)` subtracts a given number of days from a given date simply a wrapper method for subtractFromDate(d, Calendar.DAY_OF_MONTH, days)
`static java.util.Date`	`subtractFromDate(java.util.Date d, int arg0, int toSubtract)` subtracts a given number of Date-Parts (Seconds, Minutes, Days, Years,...) from a given date the type to subtract (arg0) must be a field of java.util.Calendar, i.e.: Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR, ...
`static java.util.Date`	`subtractHour(java.util.Date d)` subtract 1 hour from a given date simply a wrapper method for subtractFromDate(d, Calendar.HOUR, 1)
`static java.util.Date`	`subtractHours(java.util.Date d, int hours)` subtracts a given number of hours from a given date simply a wrapper method for subtractFromDate(d, Calendar.HOUR, hours)
`static java.util.Date`	`subtractMillisecond(java.util.Date d)` subtract 1 millisecond from a given date simply a wrapper method for subtractFromDate(d, Calendar.MILLISECOND, 1)
`static java.util.Date`	`subtractMilliseconds(java.util.Date d, int ms)` subtracts a given number of milliseconds from a given date simply a wrapper method for subtractFromDate(d, Calendar.MILLISECOND, ms)
`static java.util.Date`	`subtractMinute(java.util.Date d)` subtract 1 minute from a given date simply a wrapper method for subtractFromDate(d, Calendar.MINUTE, 1)
`static java.util.Date`	`subtractMinutes(java.util.Date d, int minutes)` subtracts a given number of minutes from a given date simply a wrapper method for subtractFromDate(d = Date, arg0 = int, toSubtract = int)
`static java.util.Date`	`subtractMonth(java.util.Date d)` subtract 1 month from a given date simply a wrapper method for subtractFromDate(d, Calendar.MONTH, 1)
`static java.util.Date`	`subtractMonths(java.util.Date d, int months)` subtracts a given number of months from a given date simply a wrapper method for subtractFromDate(d, Calendar.MONTH, months)
`static java.util.Date`	`subtractSecond(java.util.Date d)` subtract 1 second from a given date simply a wrapper method for subtractFromDate(d, Calendar.SECOND, 1)
`static java.util.Date`	`subtractSeconds(java.util.Date d, int seconds)` subtracts a given number of seconds from a given date simply a wrapper method for subtractFromDate(d = Date, arg0 = int, toSubtract = int)
`static java.util.Date`	`subtractWeek(java.util.Date d)` subtracts 1 week from a given date simply a wrapper method for subtractFromDate(d, Calendar.WEEK_OF_YEAR, 1)
`static java.util.Date`	`subtractWeeks(java.util.Date d, int weeks)` subtracts a given number of weeks from a given date simply a wrapper method for subtractFromDate(d, Calendar.WEEK_OF_YEAR, weeks)
`static java.util.Date`	`subtractYear(java.util.Date d)` subtract 1 year from a given date simply a wrapper method for subtractFromDate(d, Calendar.YEAR, 1)
`static java.util.Date`	`subtractYears(java.util.Date d, int years)` subtracts a given number of years from a given date simply a wrapper method for subtractFromDate(d, Calendar.YEAR, years)
`static javax.xml.datatype.Duration`	`timeDistance(java.util.Calendar referenceDate, java.util.Calendar targetDate)` Calculates the duration from a referrenced point in time to a target time.
`static javax.xml.datatype.Duration`	`timeDistance(java.util.Calendar reference, java.util.Calendar intervalStart, java.util.Calendar intervalEnd)` Calculates the duration from a referrenced point in time to the closest border of a time interval, unless the reference is inbetween.
`static javax.xml.datatype.Duration`	`timeDistance(java.util.Date referenceDate, java.util.Date targetDate)` Convenience method for `#calculateTimeDistance(Calender, Calendar)`
`static javax.xml.datatype.Duration`	`timeDistance(java.util.Date reference, java.util.Date intervalStart, java.util.Date intervalEnd)` Convenience method for `#calculateTimeDistance(Calender, Calendar, Calendar)`
`static java.math.BigDecimal`	`toHours(java.lang.Long ts)` Converts a given timespan (in seconds) to hours and returns a BigDecimal.
`static java.math.BigDecimal`	`toHours(java.lang.Long ts, int precision)`
`static java.time.LocalDate`	`toLocalDate(java.util.Date d)` Helper method for a quick conversion from Date to LocalDate, either with an explicit or implicit (system default) time zone.
`static java.time.LocalDate`	`toLocalDate(java.util.Date d, java.time.ZoneId timezone)`
`static java.time.LocalDateTime`	`toLocalDateTime(java.util.Date d)` Helper method for a quick conversion from Date to LocalDateTime, either with an explicit or implicit (system default) time zone.
`static java.time.LocalDateTime`	`toLocalDateTime(java.util.Date d, java.time.ZoneId timezone)`
`static java.time.LocalTime`	`toLocalTime(java.util.Date d)` Helper method for a quick conversion from Date to LocalTime, either with an explicit or implicit (system default) time zone.
`static java.time.LocalTime`	`toLocalTime(java.util.Date d, java.time.ZoneId timezone)`
`static java.math.BigDecimal`	`toMinutes(java.lang.Long ts)` Converts a given timespan (in seconds) to minutes and returns a BigDecimal.
`static java.math.BigDecimal`	`toMinutes(java.lang.Long ts, int precision)`
`static java.time.OffsetDateTime`	`toOffsetDateTime(java.util.Date d)` Helper method for a quick conversion from Date to OffsetDateTime, either with an explicit or implicit (system default) time zone.
`static java.time.OffsetDateTime`	`toOffsetDateTime(java.util.Date d, java.time.ZoneId timezone)`
`static java.time.ZonedDateTime`	`toZonedDateTime(java.util.Date d)` Helper method for a quick conversion from Date to ZonedDateTime, either with an explicit or implicit (system default) time zone.
`static java.time.ZonedDateTime`	`toZonedDateTime(java.util.Date d, java.time.ZoneId timezone)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DATEFORMAT_PATTERN
```
public static final java.lang.String DATEFORMAT_PATTERN
```
    See Also:
    
    Constant Field Values
  - MILLISECONDS_PER_SECOND
```
public static final java.math.BigDecimal MILLISECONDS_PER_SECOND
```
  - SECONDS_PER_MINUTE
```
public static final java.math.BigDecimal SECONDS_PER_MINUTE
```
  - MILLISECONDS_PER_MINUTE
```
public static final java.math.BigDecimal MILLISECONDS_PER_MINUTE
```
  - MINUTES_PER_HOUR
```
public static final java.math.BigDecimal MINUTES_PER_HOUR
```
  - SECONDS_PER_HOUR
```
public static final java.math.BigDecimal SECONDS_PER_HOUR
```
  - MILLISECONDS_PER_HOUR
```
public static final java.math.BigDecimal MILLISECONDS_PER_HOUR
```
  - HOURS_PER_DAY
```
public static final java.math.BigDecimal HOURS_PER_DAY
```
  - MINUTES_PER_DAY
```
public static final java.math.BigDecimal MINUTES_PER_DAY
```
  - SECONDS_PER_DAY
```
public static final java.math.BigDecimal SECONDS_PER_DAY
```
  - MILLISECONDS_PER_DAY
```
public static final java.math.BigDecimal MILLISECONDS_PER_DAY
```
  - STRIP_MILLISECONDS
```
public static final java.lang.String STRIP_MILLISECONDS
```
    See Also:
    
    Constant Field Values
  - STRIP_SECONDS
```
public static final java.lang.String STRIP_SECONDS
```
    See Also:
    
    Constant Field Values
  - STRIP_MINUTES
```
public static final java.lang.String STRIP_MINUTES
```
    See Also:
    
    Constant Field Values
  - STRIP_HOURS
```
public static final java.lang.String STRIP_HOURS
```
    See Also:
    
    Constant Field Values
  - STRIP_DAYS
```
public static final java.lang.String STRIP_DAYS
```
    See Also:
    
    Constant Field Values
  - STRIP_MONTHS
```
public static final java.lang.String STRIP_MONTHS
```
    See Also:
    
    Constant Field Values
  - STRIP_YEARS
```
public static final java.lang.String STRIP_YEARS
```
    See Also:
    
    Constant Field Values
  - STRIP_TIME
```
public static final java.lang.String STRIP_TIME
```
    See Also:
    
    Constant Field Values
  - STRIP_DATE
```
public static final java.lang.String STRIP_DATE
```
    See Also:
    
    Constant Field Values
- Method Detail
  - getDate
```
public static java.util.Date getDate(java.lang.String _str)
                              throws java.text.ParseException
```
    Deprecated. use L10n.parseDate instead!
    
    Returns a Date created by parsing the given String using L10n.parseDate with pattern "yyyy-MM-dd". Just a convenience method.
    
    Parameters:
    
    _str - the String to parse into a Date
    
    Returns:
    
    a matching Date
    
    Throws:
    
    java.text.ParseException
  - getMonthsList
```
public static java.util.Collection<java.lang.String> getMonthsList()
```
    Returns an ordered list of String month representations with 2 digits for usage e.g. in a ComboBox.
    
    Parameters:
    
    reversed - a boolean, if true the returned list will be reversed instead of in natural order (optional)
    
    stopMonth - if a Date is given the list will only include the first months including the month of the passed date
    
    Returns:
    
    an ordered list of String month representations with 2 digits
  - getMonthsList
```
public static java.util.Collection<java.lang.String> getMonthsList(boolean reversed)
```
  - getMonthsList
```
public static java.util.Collection<java.lang.String> getMonthsList(boolean reversed,
                                                                   java.util.Date stopMonth)
```
  - liesInLeftOpenInterval
```
public static boolean liesInLeftOpenInterval(java.util.Date candidate,
                                             TimespanI ts)
```
    wrapper for liesInInterval with a Timespan. excludes the start date of the timespan.
  - liesInLeftOpenInterval
```
public static boolean liesInLeftOpenInterval(java.util.Date candidate,
                                             TimespanI ts,
                                             java.lang.Boolean fallbackForNullCandidate)
```
  - liesInLeftOpenInterval
```
public static boolean liesInLeftOpenInterval(java.util.Date candidate,
                                             TimespanI ts,
                                             java.lang.Boolean fallbackForNullCandidate,
                                             boolean stripTime)
```
  - liesInRightOpenInterval
```
public static boolean liesInRightOpenInterval(java.util.Date candidate,
                                              TimespanI ts)
```
    wrapper for liesInInterval with a Timespan. excludes the end date of the timespan.
  - liesInRightOpenInterval
```
public static boolean liesInRightOpenInterval(java.util.Date candidate,
                                              TimespanI ts,
                                              java.lang.Boolean fallbackForNullCandidate)
```
  - liesInRightOpenInterval
```
public static boolean liesInRightOpenInterval(java.util.Date candidate,
                                              TimespanI ts,
                                              java.lang.Boolean fallbackForNullCandidate,
                                              boolean stripTime)
```
  - liesInOpenInterval
```
public static boolean liesInOpenInterval(java.util.Date candidate,
                                         TimespanI ts)
```
    wrapper for liesInInterval with a Timespan. excludes the start and end date of the timespan.
  - liesInOpenInterval
```
public static boolean liesInOpenInterval(java.util.Date candidate,
                                         TimespanI ts,
                                         java.lang.Boolean fallbackForNullCandidate)
```
  - liesInOpenInterval
```
public static boolean liesInOpenInterval(java.util.Date candidate,
                                         TimespanI ts,
                                         java.lang.Boolean fallbackForNullCandidate,
                                         boolean stripTime)
```
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     TimespanI ts)
```
    Checks if the given Date lies within the given TimespanI. If getDateStart() of the passed TimespanI returns null, it is only checked if the Date lies before or on getDateEnd(). If getDateEnd() of the passed TimespanI returns null, it is only checked if the Date lies on or after getDateStart(). If both return null, the method always returns true (because the TimeSpanI then includes "all the time"). If the passed candidate is null and fallbackForNullCandidate is null, an IllegalArgumentException is raised.
    
    Parameters:
    
    ts - the TimespanI
    
    candidate - the Date to check
    
    fallbackForNullCandidate - if the candidate is null and fallbackForNullCandidate is: null: signals IAE Boolean.FALSE: returns false Boolean.TRUE: returns true
    
    stripTime - if true the time-part of candidate and DateStart/DateEnd of the passed TimespanI are discarded before the check
    
    Returns:
    
    true if the candidate lies within the given TimespanI, false otherwise
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     TimespanI ts,
                                     java.lang.Boolean fallbackForNullCandidate)
```
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     TimespanI ts,
                                     java.lang.Boolean fallbackForNullCandidate,
                                     boolean stripTime)
```
  - liesInLeftOpenInterval
```
public static boolean liesInLeftOpenInterval(java.util.Date candidate,
                                             java.util.Date dateStart,
                                             java.util.Date dateEnd)
```
    wrapper for liesInInterval. excludes dateStart.
  - liesInLeftOpenInterval
```
public static boolean liesInLeftOpenInterval(java.util.Date candidate,
                                             java.util.Date dateStart,
                                             java.util.Date dateEnd,
                                             java.lang.Boolean fallbackForNullCandidate)
```
  - liesInLeftOpenInterval
```
public static boolean liesInLeftOpenInterval(java.util.Date candidate,
                                             java.util.Date dateStart,
                                             java.util.Date dateEnd,
                                             java.lang.Boolean fallbackForNullCandidate,
                                             boolean stripTime)
```
  - liesInRightOpenInterval
```
public static boolean liesInRightOpenInterval(java.util.Date candidate,
                                              java.util.Date dateStart,
                                              java.util.Date dateEnd)
```
    wrapper for liesInInterval. excludes the dateEnd.
  - liesInRightOpenInterval
```
public static boolean liesInRightOpenInterval(java.util.Date candidate,
                                              java.util.Date dateStart,
                                              java.util.Date dateEnd,
                                              java.lang.Boolean fallbackForNullCandidate)
```
  - liesInRightOpenInterval
```
public static boolean liesInRightOpenInterval(java.util.Date candidate,
                                              java.util.Date dateStart,
                                              java.util.Date dateEnd,
                                              java.lang.Boolean fallbackForNullCandidate,
                                              boolean stripTime)
```
  - liesInOpenInterval
```
public static boolean liesInOpenInterval(java.util.Date candidate,
                                         java.util.Date dateStart,
                                         java.util.Date dateEnd)
```
    wrapper for liesInInterval. excludes dateStart and dateEnd.
  - liesInOpenInterval
```
public static boolean liesInOpenInterval(java.util.Date candidate,
                                         java.util.Date dateStart,
                                         java.util.Date dateEnd,
                                         java.lang.Boolean fallbackForNullCandidate)
```
  - liesInOpenInterval
```
public static boolean liesInOpenInterval(java.util.Date candidate,
                                         java.util.Date dateStart,
                                         java.util.Date dateEnd,
                                         java.lang.Boolean fallbackForNullCandidate,
                                         boolean stripTime)
```
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     java.util.Date dateStart,
                                     java.util.Date dateEnd)
```
    Checks if the given candidate lies within the given dateStart and dateEnd. If the passed candidate is null and fallbackForNullCandidate is null, an IllegalArgumentException is raised.
    
    Parameters:
    
    dateStart - the start date of the interval; null is interpreted as Epoch
    
    dateEnd - the end date of the interval; null is interpreted as Infinity
    
    candidate - the date to check
    
    fallbackForNullCandidate - if the candidate is null and fallbackForNullCandidate is: null: signals IAE Boolean.FALSE: returns false Boolean.TRUE: returns true
    
    excludingLeft - whether the left boundary is included or excluded
    
    excludingRight - whether the right boundary is included or excluded
    
    stripTime - if true the time-part of candidate, dateStart and dateEnd are discarded before the check
    
    Returns:
    
    true if the candidate lies within the given Dates, false otherwise
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     java.util.Date dateStart,
                                     java.util.Date dateEnd,
                                     java.lang.Boolean fallbackForNullCandidate)
```
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     java.util.Date dateStart,
                                     java.util.Date dateEnd,
                                     java.lang.Boolean fallbackForNullCandidate,
                                     boolean excludingLeft)
```
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     java.util.Date dateStart,
                                     java.util.Date dateEnd,
                                     java.lang.Boolean fallbackForNullCandidate,
                                     boolean excludingLeft,
                                     boolean excludingRight)
```
  - liesInInterval
```
public static boolean liesInInterval(java.util.Date candidate,
                                     java.util.Date dateStart,
                                     java.util.Date dateEnd,
                                     java.lang.Boolean fallbackForNullCandidate,
                                     boolean excludingLeft,
                                     boolean excludingRight,
                                     boolean stripTime)
```
  - overlap
```
@Deprecated
public static boolean overlap(TimespanI _ts1,
                                          TimespanI _ts2)
```
    Deprecated. use the far more comprehensible method TimespanI::overlapsWith instead FIXME (electris)StromPOD->checkForOverlappingStromlieferinfos() is a similar yet different method. if you have a different case than in this function approaches, feel free to copy from there :-) (-> i have tried to merge them, but the matter is too complex for me and the functions vary too much)
    
    Checks if the given TimespanIs overlap.
    
    Parameters:
    
    _ts1 - the first TimespanI
    
    _ts2 - the second TimespanI
    
    _strict - if true (the default) the Timespans will be considered to be overlapping also when the end date of one is exactly the start date of the other; if false such a case will still not be considered overlapping.
    
    Returns:
    
    true if the given TimespanIs overlap, false otherwise.
    
    Todo:
    
    the code of this method should probably be rewritten.
  - overlap
```
public static boolean overlap(TimespanI _ts1,
                              TimespanI _ts2,
                              boolean _strict)
```
  - overlaps
```
public static boolean overlaps(TimespanI _ts,
                               TimespanI[] _tss)
```
    Checks if the given TimespanI overlaps any of the other given TimespanIs.
    
    Parameters:
    
    _ts - the TimespanI to check
    
    _tss - an array of TimespanIs against which _ts should be checked
    
    Returns:
    
    true if the given TimespanIs overlaps any of the other given TimespanIs, false otherwise.
  - checkTimespan
```
public static void checkTimespan(TimespanI _ts)
                          throws InvalidTimespanException
```
    Checks the given TimespanI for errors. Currently only checks if getDateStart() is before (or on) getDateEnd() if both are set.
    
    Parameters:
    
    _ts - the TimespanI to check
    
    Throws:
    
    InvalidTimespanException - in case the TimespanI is invalid
  - createCalendar
```
public static java.util.Calendar createCalendar()
```
    Creates a new java.util.Calendar from the given Date object.
  - createCalendar
```
public static java.util.Calendar createCalendar(java.util.Date _d)
```
  - createCalendar
```
public static java.util.Calendar createCalendar(long _millis)
```
    Creates a new java.util.Calendar represeting the passed time since epoch in millis.
  - nullSafeBefore
```
public static boolean nullSafeBefore(java.util.Date date1,
                                     java.util.Date date2)
```
    Returns true if the first date is temporally before the second one. If any date is null, false is returned.
  - nullSafeAfter
```
public static boolean nullSafeAfter(java.util.Date date1,
                                    java.util.Date date2)
```
    Returns true if first date is temporally after the second one. If any date is null, false is returned.
  - isBeforeOrSameDate
```
public static boolean isBeforeOrSameDate(java.util.Calendar cal1,
                                         java.util.Calendar cal2)
```
    Returns true if the passed Calendars are equal or the first date is temporally before the second one.
  - isAfterOrSameDate
```
public static boolean isAfterOrSameDate(java.util.Calendar cal1,
                                        java.util.Calendar cal2)
```
    Returns true if the passed Calendars are equal or the first date is temporally after the second one.
  - isBeforeOrSameDate
```
public static boolean isBeforeOrSameDate(java.util.Date date1,
                                         java.util.Date date2)
```
    Returns true if the passed dates are equal or the first date is temporally before the second one.
  - isAfterOrSameDate
```
public static boolean isAfterOrSameDate(java.util.Date date1,
                                        java.util.Date date2)
```
    Returns true if the passed dates are equal or the first date is temporally after the second one.
  - isSameDayOfWeek
```
public static boolean isSameDayOfWeek(java.util.Date d1,
                                      java.util.Date d2)
```
    Returns true if the passed dates have the same day of the week.
    
    Parameters:
    
    d1 - the first date to compare
    
    d2 - the second date to compare
    
    Returns:
    
    true if the passed dates have the same day of the week; false otherwise
  - isBeforeOrSameDay
```
public static boolean isBeforeOrSameDay(java.util.Date dateToCheck,
                                        java.util.Date anchorDate)
```
    Returns true if the passed dates are on the same day or the first date is temporally before the anchor date.
    
    Parameters:
    
    dateToCheck - the Date for which should be determined if it is before or on the same day as the anchor date
    
    anchorDate - the anchor date against which to check the first date
    
    ignoreTime - if true, the time will be ignored and the difference of the Dates will only be compared in regards to the day they are on
  - isBeforeOrSameDay
```
public static boolean isBeforeOrSameDay(java.util.Date dateToCheck,
                                        java.util.Date anchorDate,
                                        boolean ignoreTime)
```
  - isAfterOrSameDay
```
public static boolean isAfterOrSameDay(java.util.Date dateToCheck,
                                       java.util.Date anchorDate)
```
    Returns true if the passed dates are on the same day or the first date is temporally after the anchor date.
    
    Parameters:
    
    dateToCheck - the Date for which should be determined if it is after or on the same day as the anchor date
    
    anchorDate - the anchor date against which to check the first date
    
    ignoreTime - if true, the time will be ignored and the difference of the Dates will only be compared in regards to the day they are on
  - isAfterOrSameDay
```
public static boolean isAfterOrSameDay(java.util.Date dateToCheck,
                                       java.util.Date anchorDate,
                                       boolean ignoreTime)
```
  - isNextDay
```
public static boolean isNextDay(java.util.Date nextDay,
                                java.util.Date day)
```
    Returns true if the "nextDay" (1st argument) is the same day as the next day after the "day" (2nd argument).
    
    Parameters:
    
    nextDay - the date to check if it is the next day after the specified day
    
    day - the reference date
    
    Returns:
    
    true if the "nextDay" is the same day as the next day after the "day"; false otherwise
  - isSameDay
```
public static boolean isSameDay(java.util.Date date1,
                                java.util.Date date2)
```
    Returns true if the passed dates are on the same day or both dates are null.
    
    Parameters:
    
    date1 - the first date to compare
    
    date2 - the second date to compare
    
    Returns:
    
    true if the passed dates are on the same day or both dates are null; false otherwise
  - isPreviousDay
```
public static boolean isPreviousDay(java.util.Date previousDay,
                                    java.util.Date day)
```
    Returns true if the "previousDay" (1st argument) is the same day as the previous day before the "day" (2nd argument).
    
    Parameters:
    
    previousDay - the date to check if it is the previous day before the specified day
    
    day - the reference date
    
    Returns:
    
    true if the "previousDay" is the same day as the previous day before the "day"; false otherwise
  - isMonth
```
public static boolean isMonth(java.util.Date d,
                              int month)
```
    Returns true if the passed date has the specified month.
    
    Parameters:
    
    d - the date to check
    
    month - the month to compare with the month of the date (Calendar.JANUARY or 0, Calendar.FEBRUARY or 1, etc.)
    
    Returns:
    
    true if the passed date has the specified month; false otherwise
  - isSameMonth
```
public static boolean isSameMonth(java.util.Date date1,
                                  java.util.Date date2)
```
    Returns true if the passed dates are in the same month. Handles null values like equals().
    
    Parameters:
    
    date1 - the first date to compare
    
    date2 - the second date to compare
    
    Returns:
    
    true if the passed dates are in the same month; false otherwise
  - isSameYear
```
public static boolean isSameYear(java.util.Date date1,
                                 java.util.Date date2)
```
    Returns true if the passed dates are in the same year or both dates are null.
    
    Parameters:
    
    date1 - the first date to compare
    
    date2 - the second date to compare
    
    Returns:
    
    true if the passed dates are in the same year or both dates are null; false otherwise
  - isSaturday
```
public static boolean isSaturday(java.util.Date d)
```
    Returns true if the passed date is a saturday.
  - isSunday
```
public static boolean isSunday(java.util.Date d)
```
    Returns true if the passed date is a sunday.
  - isWeekend
```
public static boolean isWeekend(java.util.Date d)
```
    Returns true if the passed date is a weekend day.
  - isSpecificDay
```
public static boolean isSpecificDay(java.util.Date d,
                                    int day)
```
    Returns true if the passed date is a given day. For example: Calendar.MONDAY,...
  - maxCalendar
```
public static java.util.Calendar maxCalendar(java.util.Calendar _d1,
                                             java.util.Calendar _d2)
```
    Returns the later of the dates represented by the given Calendars.
    
    Parameters:
    
    _d1 - the first Calendar to be compared
    
    _d2 - the second Calendar to be compared
    
    _nullMeansInfinity - if true, if one of the Calendars is null, it is interpreted as infinity and thus returned if false(default), a null Calendar is interpreted as the earlier date
  - maxCalendar
```
public static java.util.Calendar maxCalendar(java.util.Calendar _d1,
                                             java.util.Calendar _d2,
                                             boolean _nullMeansInfinity)
```
  - maxDate
```
public static java.util.Date maxDate(java.util.Date _d1,
                                     java.util.Date _d2)
```
    Returns the later of the given Dates.
    
    Parameters:
    
    _d1 - the first Date to be compared
    
    _d2 - the second Date to be compared
    
    _nullMeansInfinity - if true, if one of the Dates is null, it is interpreted as infinity and thus returned if false(default), a null Date is interpreted as the earlier date
  - maxDate
```
public static java.util.Date maxDate(java.util.Date _d1,
                                     java.util.Date _d2,
                                     boolean _nullMeansInfinity)
```
  - minCalendar
```
public static java.util.Calendar minCalendar(java.util.Calendar _d1,
                                             java.util.Calendar _d2)
```
    Returns the earlier of the dates represented by the given Calendars.
    
    Parameters:
    
    _d1 - the first Calendar to be compared
    
    _d2 - the second Calendar to be compared
    
    _nullMeansInfinity - if true, if one of the Calendars is null, it is interpreted as epoch and thus returned if false(default), a null Calendar is interpreted as the later date
  - minCalendar
```
public static java.util.Calendar minCalendar(java.util.Calendar _d1,
                                             java.util.Calendar _d2,
                                             boolean _nullMeansEpoch)
```
  - minDate
```
public static java.util.Date minDate(java.util.Date _d1,
                                     java.util.Date _d2)
```
    Returns the earlier of the given Dates.
    
    Parameters:
    
    _d1 - the first Date to be compared
    
    _d2 - the second Date to be compared
    
    _nullMeansEpoch - if true, if one of the Dates is null, it is interpreted as epoch and thus returned if false(default), a null Date is interpreted as the later date
  - minDate
```
public static java.util.Date minDate(java.util.Date _d1,
                                     java.util.Date _d2,
                                     boolean _nullMeansEpoch)
```
  - longToDate
```
public static java.util.Date longToDate(java.lang.Long _l)
```
    constructs a Date-object representing the time expressed by the given value as milliseconds
    
    Parameters:
    
    _l - the milliseconds from which a Date shall be constructed
    
    Returns:
    
    a Date-object representing the time expressed by the passed value as milliseconds
  - getRelevantTimespan
```
public static DateContainer getRelevantTimespan(java.util.Date _globalFrom,
                                                java.util.Date _globalTo,
                                                java.util.Date _localFrom,
                                                java.util.Date _localTo)
```
    determines and returns the relevant part of a given timespan, i.e. the part which lies within a given global time-frame
    
    Parameters:
    
    _globalFrom - the beginning of the outer timespan
    
    _globalTo - the ending of the outer timespan
    
    _localFrom - the beginning of the inner timespan
    
    _localTo - the ending of the inner timespan
    
    Returns:
    
    a DateContainer representing the resulting timespan which is left, i.e. which lies within the given global time-frame
  - newDuration
```
public static javax.xml.datatype.Duration newDuration()
```
    Creates a new javax.xml.datatype.Duration from a string representation.
    
    Parameters:
    
    s - the javax.xml.datatype.Duration as its string representation, "PnYnMnDTnHnMnS", as defined in XML Schema 1.0 section 3.2.6.1. Defaults to "P0Y0M0DT0H0M0S".
    
    Returns:
    
    the newly created javax.xml.datatype.Duration
  - newDuration
```
public static javax.xml.datatype.Duration newDuration(java.lang.String s)
```
  - newDurationFromSeconds
```
public static javax.xml.datatype.Duration newDurationFromSeconds(int seconds)
```
    Creates a new javax.xml.datatype.Duration from a number of seconds.
    
    Parameters:
    
    seconds - the number of seconds in the duration
    
    Returns:
    
    the newly created javax.xml.datatype.Duration
  - newDuration
```
public static javax.xml.datatype.Duration newDuration(int years,
                                                      int months,
                                                      int days,
                                                      int hours,
                                                      int minutes,
                                                      int seconds)
```
    Creates a new javax.xml.datatype.Duration from a number of years, months, days, hours, minutes, and seconds.
    
    Parameters:
    
    years - the number of years in the duration
    
    months - the number of months in the duration
    
    days - the number of days in the duration
    
    hours - the number of hours in the duration
    
    minutes - the number of minutes in the duration
    
    seconds - the number of seconds in the duration
    
    Returns:
    
    the newly created javax.xml.datatype.Duration
  - newNegativeDurationFromSeconds
```
public static javax.xml.datatype.Duration newNegativeDurationFromSeconds(int seconds)
```
    Creates a new negative javax.xml.datatype.Duration from a number of seconds.
    
    Parameters:
    
    seconds - the number of seconds in the duration
    
    Returns:
    
    the newly created javax.xml.datatype.Duration
  - newNegativeDuration
```
public static javax.xml.datatype.Duration newNegativeDuration(int years,
                                                              int months,
                                                              int days,
                                                              int hours,
                                                              int minutes,
                                                              int seconds)
```
    Creates a new negative javax.xml.datatype.Duration from a number of years, months, days, hours, minutes, and seconds.
    
    Parameters:
    
    years - the number of years in the duration
    
    months - the number of months in the duration
    
    days - the number of days in the duration
    
    hours - the number of hours in the duration
    
    minutes - the number of minutes in the duration
    
    seconds - the number of seconds in the duration
    
    Returns:
    
    the newly created javax.xml.datatype.Duration
  - getNextMatchingDate
```
public static java.util.Date getNextMatchingDate(java.lang.String _cronDef)
```
    Evaluates a cron definition and returns the next date the definition matches on. Uses the current time by default, unless an explicit reference date has been provided. Matches using the default (i.e. jvm local) timezone unless an explicit timezone has been provided.
    
    Parameters:
    
    _cronDef - the cron definition string, nonnull.
    
    fromReferenceDate - if not null, defined the 'now' regarding the next date calculation. If null, uses the current time since epoch.
    
    timeZone - the nullable timezone to calculate the matching date for. If null, uses the current default timezone.
    
    Returns:
    
    the date the cronDef matches the next time, nonnull.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the _cronDef is in an invalid pattern
  - getNextMatchingDate
```
public static java.util.Date getNextMatchingDate(java.lang.String _cronDef,
                                                 java.util.Date fromReferenceDate)
```
  - getNextMatchingDate
```
public static java.util.Date getNextMatchingDate(java.lang.String _cronDef,
                                                 java.util.Date fromReferenceDate,
                                                 java.util.TimeZone timeZone)
```
  - adjustTimeToMinimum
```
public static java.util.Date adjustTimeToMinimum(java.util.Date _date1,
                                                 java.util.Date _date2)
```
    Returns:
    
    a copy of _date1 if its time part (hours, minutes, secondes) is already smaller than the time of _date2 or a copy of _date1 with its time part set to the time part of _date2 if that is smaller than the current time of _date1.
  - getYearAsInt
```
public static int getYearAsInt(java.util.Date d)
```
    Returns an int with the year of the given date, -1 if the given date is null
    
    Parameters:
    
    d - the date to get the year as int for
    
    Returns:
    
    the int for the year
  - getHourOfDayAsInt
```
public static int getHourOfDayAsInt(java.util.Date d)
```
    Returns an int with the hour of day of the given date, -1 if the given date is null
    
    Parameters:
    
    d - the date to get the hour of day as int for
    
    Returns:
    
    the int for the hour of day
  - getMinuteAsInt
```
public static int getMinuteAsInt(java.util.Date d)
```
    Returns an int with the minute of the given date, -1 if the given date is null
    
    Parameters:
    
    d - the date to get the hour of day as int for
    
    Returns:
    
    the int for the minute
  - getQuartal
```
public static java.lang.String getQuartal(java.util.Date _d)
```
    Returns String object with quarter and year of given date, empty string if date is null
    
    Parameters:
    
    _d - the date to get the quarter and year for
    
    Returns:
    
    the quarter and year as string
  - getMonth
```
public static int getMonth(java.util.Date d)
```
    Returns an int with the month of the given date, -1 if the given date is null.
    
    Parameters:
    
    d - the date to get the month as int for
    
    oneBased - if true, the result is in the range of 1..12 (default). if false, it is in the range of 0..11
    
    Returns:
    
    the int for the month
  - getMonth
```
public static int getMonth(java.util.Date d,
                           boolean oneBased)
```
  - getDay
```
public static int getDay(java.util.Date d)
```
    Returns an int with the day of the given date, -1 is the given date is null. 1 based.
    
    Parameters:
    
    d - the date to get the day as int for
    
    Returns:
    
    the int for the day
  - setDayOfMonth
```
public static java.util.Date setDayOfMonth(java.util.Date d,
                                           int day)
```
    sets the day of the given month to the given day, 1 based the value of the day gets truncated to the limits of the current month
  - getHourOfDay
```
public static java.lang.String getHourOfDay(java.util.Date _date)
```
  - setMonth
```
public static java.util.Date setMonth(java.util.Date d,
                                      int month)
```
    Parameters:
    
    d - the date from which the month is to be changed
    
    month - a value representing the month that is to be set
    
    oneBased - if true, the value of the month is in the range 1..12 (default); if false it is in the range of 0..11
    
    Returns:
    
    a new Date with the given Month set
  - setMonth
```
public static java.util.Date setMonth(java.util.Date d,
                                      int month,
                                      boolean oneBased)
```
  - setYear
```
public static java.util.Date setYear(java.util.Date d,
                                     int y)
```
    Sets the year in the passed Date object to the passed year.
  - getYear
```
public static java.lang.String getYear(java.util.Date _date)
```
  - getWeekOfYear
```
public static java.lang.String getWeekOfYear(java.util.Date _date)
```
  - addMillisecond
```
public static java.util.Date addMillisecond(java.util.Date d)
```
    add 1 millisecond to a given date simply a wrapper method for addToDate(d, Calendar.MILLISECOND, 1)
    
    Parameters:
    
    d - the date to add a millisecond to
    
    Returns:
    
    the recalculated date
  - subtractMillisecond
```
public static java.util.Date subtractMillisecond(java.util.Date d)
```
    subtract 1 millisecond from a given date simply a wrapper method for subtractFromDate(d, Calendar.MILLISECOND, 1)
    
    Parameters:
    
    d - the date to subtract a millisecond from
    
    Returns:
    
    the recalculated date
  - addMilliseconds
```
public static java.util.Date addMilliseconds(java.util.Date d,
                                             int ms)
```
    adds a given number of milliseconds to a given date simply a wrapper method for addToDate(d, Calendar.MILLISECOND, ms)
    
    Parameters:
    
    d - the date to add the given number of milliseconds to
    
    ms - the number of milliseconds to add
    
    Returns:
    
    the recalculated date
  - subtractMilliseconds
```
public static java.util.Date subtractMilliseconds(java.util.Date d,
                                                  int ms)
```
    subtracts a given number of milliseconds from a given date simply a wrapper method for subtractFromDate(d, Calendar.MILLISECOND, ms)
    
    Parameters:
    
    d - the date to subtract the given number of milliseconds from
    
    ms - the number of milliseconds to subtract
    
    Returns:
    
    the recalculated date
  - addSecond
```
public static java.util.Date addSecond(java.util.Date d)
```
    add 1 second to a given date simply a wrapper method for addToDate(d, Calendar.SECOND, 1)
    
    Parameters:
    
    d - the date to add a second to
    
    Returns:
    
    the recalculated date
  - subtractSecond
```
public static java.util.Date subtractSecond(java.util.Date d)
```
    subtract 1 second from a given date simply a wrapper method for subtractFromDate(d, Calendar.SECOND, 1)
    
    Parameters:
    
    d - the date to subtract a second from
    
    Returns:
    
    the recalculated date
  - addSeconds
```
public static java.util.Date addSeconds(java.util.Date d,
                                        int seconds)
```
    adds a given number of seconds to a given date simply a wrapper method for addToDate(d, Calendar.SECOND, seconds)
    
    Parameters:
    
    d - the date to add the given number of seconds to
    
    seconds - the number of seconds to add
    
    Returns:
    
    the recalculated date
  - subtractSeconds
```
public static java.util.Date subtractSeconds(java.util.Date d,
                                             int seconds)
```
    subtracts a given number of seconds from a given date simply a wrapper method for subtractFromDate(d = Date, arg0 = int, toSubtract = int)
    
    Parameters:
    
    d - the date to subtract the given number of seconds from
    
    seconds - the number of seconds to subtract
    
    Returns:
    
    the recalculated date
  - addMinute
```
public static java.util.Date addMinute(java.util.Date d)
```
    add 1 minute to a given date simply a wrapper method for addToDate(d, Calendar.MINUTE, 1)
    
    Parameters:
    
    d - the date to add a minute to
    
    Returns:
    
    the recalculated date
  - subtractMinute
```
public static java.util.Date subtractMinute(java.util.Date d)
```
    subtract 1 minute from a given date simply a wrapper method for subtractFromDate(d, Calendar.MINUTE, 1)
    
    Parameters:
    
    d - the date to subtract a minute from
    
    Returns:
    
    the recalculated date
  - addMinutes
```
public static java.util.Date addMinutes(java.util.Date d,
                                        int minutes)
```
    adds a given number of minutes to a given date simply a wrapper method for addToDate(d, Calendar.MINUTE, minutes)
    
    Parameters:
    
    d - the date to add the given number of minutes to
    
    minutes - the number of minutes to add
    
    Returns:
    
    the recalculated date
  - subtractMinutes
```
public static java.util.Date subtractMinutes(java.util.Date d,
                                             int minutes)
```
    subtracts a given number of minutes from a given date simply a wrapper method for subtractFromDate(d = Date, arg0 = int, toSubtract = int)
    
    Parameters:
    
    d - the date to subtract the given number of minutes from
    
    minutes - the number of minutes to subtract
    
    Returns:
    
    the recalculated date
  - addHour
```
public static java.util.Date addHour(java.util.Date d)
```
    add 1 hour to a given date simply a wrapper method for addToDate(d, Calendar.HOUR, 1)
    
    Parameters:
    
    d - the date to add an hour to
    
    Returns:
    
    the recalculated date
  - subtractHour
```
public static java.util.Date subtractHour(java.util.Date d)
```
    subtract 1 hour from a given date simply a wrapper method for subtractFromDate(d, Calendar.HOUR, 1)
    
    Parameters:
    
    d - the date to subtract an hour from
    
    Returns:
    
    the recalculated date
  - addHours
```
public static java.util.Date addHours(java.util.Date d,
                                      int hours)
```
    adds a given number of hours to a given date simply a wrapper method for addToDate(d, Calendar.HOUR, hours)
    
    Parameters:
    
    d - the date to add the given number of hours to
    
    hours - the number of hours to add
    
    Returns:
    
    the recalculated date
  - subtractHours
```
public static java.util.Date subtractHours(java.util.Date d,
                                           int hours)
```
    subtracts a given number of hours from a given date simply a wrapper method for subtractFromDate(d, Calendar.HOUR, hours)
    
    Parameters:
    
    d - the date to subtract the given number of hours from
    
    hours - the number of hours to subtract
    
    Returns:
    
    the recalculated date
  - addDay
```
public static java.util.Date addDay(java.util.Date d)
```
    add 1 day to a given date simply a wrapper method for addToDate(d, Calendar.DAY_OF_MONTH, 1)
    
    Parameters:
    
    d - the date to add a day to
    
    Returns:
    
    the recalculated date
  - subtractDay
```
public static java.util.Date subtractDay(java.util.Date d)
```
    subtracts 1 day from a given date simply a wrapper method for subtractFromDate(d, Calendar.DAY_OF_MONTH, 1)
    
    Parameters:
    
    d - the date to subtract a day from
    
    Returns:
    
    the recalculated date
  - addDays
```
public static java.util.Date addDays(java.util.Date d,
                                     int days)
```
    adds a given number of days to a given date simply a wrapper method for addToDate(d, Calendar.DAY_OF_MONTH, days)
    
    Parameters:
    
    d - the date to add the given number of days to
    
    days - the number of days to add
    
    Returns:
    
    the recalculated date
  - subtractDays
```
public static java.util.Date subtractDays(java.util.Date d,
                                          int days)
```
    subtracts a given number of days from a given date simply a wrapper method for subtractFromDate(d, Calendar.DAY_OF_MONTH, days)
    
    Parameters:
    
    d - the date to subtract the given number of days from
    
    days - the number of days to subtract
    
    Returns:
    
    the recalculated date
  - addWeek
```
public static java.util.Date addWeek(java.util.Date d)
```
    add 1 week to a given date simply a wrapper method for addToDate(d, Calendar.WEEK_OF_YEAR, 1)
    
    Parameters:
    
    d - the date to add a week to
    
    Returns:
    
    the recalculated date
  - subtractWeek
```
public static java.util.Date subtractWeek(java.util.Date d)
```
    subtracts 1 week from a given date simply a wrapper method for subtractFromDate(d, Calendar.WEEK_OF_YEAR, 1)
    
    Parameters:
    
    d - the date to subtract a week from
    
    Returns:
    
    the recalculated date
  - addWeeks
```
public static java.util.Date addWeeks(java.util.Date d,
                                      int weeks)
```
    adds a given number of weeks to a given date simply a wrapper method for addToDate(d, Calendar.WEEK_OF_YEAR, weeks)
    
    Parameters:
    
    d - the date to add the given number of weeks to
    
    weeks - the number of weeks to add
    
    Returns:
    
    the recalculated date
  - subtractWeeks
```
public static java.util.Date subtractWeeks(java.util.Date d,
                                           int weeks)
```
    subtracts a given number of weeks from a given date simply a wrapper method for subtractFromDate(d, Calendar.WEEK_OF_YEAR, weeks)
    
    Parameters:
    
    d - the date to subtract the given number of weeks from
    
    weeks - the number of weeks to subtract
    
    Returns:
    
    the recalculated date
  - addMonth
```
public static java.util.Date addMonth(java.util.Date d)
```
    add 1 month to a given date simply a wrapper method for addToDate(d, Calendar.MONTH, 1)
    
    Parameters:
    
    d - the date to add a month to
    
    Returns:
    
    the recalculated date
  - subtractMonth
```
public static java.util.Date subtractMonth(java.util.Date d)
```
    subtract 1 month from a given date simply a wrapper method for subtractFromDate(d, Calendar.MONTH, 1)
    
    Parameters:
    
    d - the date to subtract a month from
    
    Returns:
    
    the recalculated date
  - addMonths
```
public static java.util.Date addMonths(java.util.Date d,
                                       int months)
```
    adds a given number of months to a given date simply a wrapper method for addToDate(d, Calendar.MONTH, months)
    
    Parameters:
    
    d - the date to add the given number of months to
    
    months - the number of months to add
    
    Returns:
    
    the recalculated date
  - subtractMonths
```
public static java.util.Date subtractMonths(java.util.Date d,
                                            int months)
```
    subtracts a given number of months from a given date simply a wrapper method for subtractFromDate(d, Calendar.MONTH, months)
    
    Parameters:
    
    d - the date to subtract the given number of months from
    
    months - the number of months to subtract
    
    Returns:
    
    the recalculated date
  - addYear
```
public static java.util.Date addYear(java.util.Date d)
```
    add 1 year to a given date simply a wrapper method for addToDate(d, Calendar.YEAR, 1)
    
    Parameters:
    
    d - the date to add a year to
    
    Returns:
    
    the recalculated date
  - subtractYear
```
public static java.util.Date subtractYear(java.util.Date d)
```
    subtract 1 year from a given date simply a wrapper method for subtractFromDate(d, Calendar.YEAR, 1)
    
    Parameters:
    
    d - the date to subtract a year from
    
    Returns:
    
    the recalculated date
  - addYears
```
public static java.util.Date addYears(java.util.Date d,
                                      int years)
```
    adds a given number of years to a given date simply a wrapper method for addToDate(d, Calendar.YEAR, years)
    
    Parameters:
    
    d - the date to add the given number of years to
    
    years - the number of years to add
    
    Returns:
    
    the recalculated date
  - subtractYears
```
public static java.util.Date subtractYears(java.util.Date d,
                                           int years)
```
    subtracts a given number of years from a given date simply a wrapper method for subtractFromDate(d, Calendar.YEAR, years)
    
    Parameters:
    
    d - the date to subtract the given number of years from
    
    years - the number of years to subtract
    
    Returns:
    
    the recalculated date
  - addToDate
```
public static java.util.Date addToDate(java.util.Date d,
                                       java.util.concurrent.TimeUnit unit,
                                       int toAdd)
```
    adds the given amount of the given TimeUnit to the given date values given with unit microseconds or nanoseconds are being converted to milliseconds first
    
    Parameters:
    
    d - the date to add the given amount to
    
    unit - the unit of the given amount
    
    toAdd - the amount of the given TimeUnit to add
    
    Returns:
    
    the recalculated date
  - addToDate
```
public static java.util.Date addToDate(java.util.Date d,
                                       int arg0,
                                       int toAdd)
```
    adds a given number of Date-Parts (Seconds, Minutes, Days, Years,...) to a given date the type to add (arg0) must be a field of java.util.Calendar, i.e.: Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR, ...
    
    Parameters:
    
    d - the date to add the given number to
    
    arg0 - the type of Date-Part to add
    
    toAdd - the number of Date-Part to add
    
    Returns:
    
    the recalculated date
  - subtractFromDate
```
public static java.util.Date subtractFromDate(java.util.Date d,
                                              int arg0,
                                              int toSubtract)
```
    subtracts a given number of Date-Parts (Seconds, Minutes, Days, Years,...) from a given date the type to subtract (arg0) must be a field of java.util.Calendar, i.e.: Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR, ...
    
    Parameters:
    
    d - the date to subtract the given number from
    
    arg0 - the type of Date-Part to subtract
    
    toAdd - the number of Date-Part to subtract (positive value)
    
    Returns:
    
    the recalculated date
  - datesToDurationMillis
```
public static javax.xml.datatype.Duration datesToDurationMillis(java.util.Date from,
                                                                java.util.Date till)
```
    determines and returns the relevant part of a given timespan, i.e. the part which lies within a given global time-frame
    
    Parameters:
    
    from - a Date object
    
    till - another Date object
    
    Returns:
    
    a javax.xml.datatype.Duration object from the difference between the two dates. CAUTION. As all information regarding as to when these dates occurred is ignored, this function's result might be wrong (think daylight saving time boundaries, leap years, time zones, and similar phenomena). Use this function only to calculate "canonical" milliseconds between two Dates. Depending on the (timely) order of the two Date objects, the result may be a negative Duration.
  - timeDistance
```
public static javax.xml.datatype.Duration timeDistance(java.util.Calendar reference,
                                                       java.util.Calendar intervalStart,
                                                       java.util.Calendar intervalEnd)
```
    Calculates the duration from a referrenced point in time to the closest border of a time interval, unless the reference is inbetween. Also see method #calculateTimeDistance(Calender, Calendar)
    Note: intervalStart has to be earlier than intervalEnd
    
    Parameters:
    
    reference - mandatory reference date, e.g. 'now'
    
    intervalStart - mandatory, marks the start of the time interval
    
    intervalEnd - mandatory, marks the end of the time interval
    
    Returns:
    
    a javax.xml.datatype.Duration, its values are... = 0 : if intervalStart <= reference <= intervalEnd < 0 : if reference < intervalStart, T-minus countdown to start > 0 : if intervalEnd < reference, count up from end null : if no Duration could be constructed
  - timeDistance
```
public static javax.xml.datatype.Duration timeDistance(java.util.Calendar referenceDate,
                                                       java.util.Calendar targetDate)
```
    Calculates the duration from a referrenced point in time to a target time. The returned duration is negative, if the referenceDate is before the targetDate. The value orients itself on a naive understanding of time.
    Examples:
    - From 00:00:00 to 06:00:00 always returns 6 hours, even when switching to daylight savings time inbetween.
    - A return value of 1 Day is similar to the verbal statement: 'Tomorrow at the same time'
    Parameters:
    
    referenceDate - mandatory Calendar object of the reference date
    
    targetDate - mandatory Calendar object, marks the start of the time interval
    
    Returns:
    
    a javax.xml.datatype.Duration object, its values can be = 0 : if referenceDate = targetDate, or < 0 : if referenceDate < targetDate, or > 0 : if targetDate < referenceDate, or null : if no Duration could be constructed
  - timeDistance
```
public static javax.xml.datatype.Duration timeDistance(java.util.Date reference,
                                                       java.util.Date intervalStart,
                                                       java.util.Date intervalEnd)
```
    Convenience method for #calculateTimeDistance(Calender, Calendar, Calendar)
  - timeDistance
```
public static javax.xml.datatype.Duration timeDistance(java.util.Date referenceDate,
                                                       java.util.Date targetDate)
```
    Convenience method for #calculateTimeDistance(Calender, Calendar)
  - nanosTo
```
public static long nanosTo(long nanos,
                           java.util.concurrent.TimeUnit timeUnit)
```
    Converts the passed nano-second value to the passed TimeUnit and returns the full units of the desired kind (no rounding!) Allowed values are TimeUnit.MICROSECONDS, TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS and TimeUnit.DAYS.
    
    Parameters:
    
    nanos - a long containing the nanoseconds to convert
    
    timeUnit - an TimeUnit specifying the unit to convert to
    
    Returns:
    
    a long containing the converted value in full units of the desired kind
  - setTime
```
public static java.util.Date setTime(java.util.Date _date,
                                     int _hours,
                                     int _minutes,
                                     int _seconds,
                                     int _ms)
```
    Convenience method to set get a copy of a given Date with the time values set to the given time. If any of the values is < 0 it will not be set.
  - setMaxTime
```
public static java.util.Date setMaxTime(java.util.Date date)
```
    Returns:
    
    the time of the given date to its maximum, effectively representing the last second of that day. Or null, if the given date was null.
  - minutesToHours
```
public static java.math.BigDecimal minutesToHours(java.math.BigDecimal mins)
```
    Converts a given amount in minutes to hours and returns a BigDecimal.
  - minutesToHours
```
public static java.math.BigDecimal minutesToHours(java.math.BigDecimal mins,
                                                  int precision)
```
  - minutesToHours
```
public static java.math.BigDecimal minutesToHours(java.lang.Long mins)
```
    Converts a given amount in minutes to hours and returns a BigDecimal.
  - minutesToHours
```
public static java.math.BigDecimal minutesToHours(java.lang.Long mins,
                                                  int precision)
```
  - minutesToSeconds
```
public static java.math.BigDecimal minutesToSeconds(java.math.BigDecimal mins)
```
    Converts a given amount in minutes to seconds and returns a BigDecimal.
  - minutesToSeconds
```
public static java.lang.Long minutesToSeconds(java.lang.Long mins)
```
    Converts a given amount in minutes to seconds and returns a Long.
  - toMinutes
```
public static java.math.BigDecimal toMinutes(java.lang.Long ts)
```
    Converts a given timespan (in seconds) to minutes and returns a BigDecimal.
  - toMinutes
```
public static java.math.BigDecimal toMinutes(java.lang.Long ts,
                                             int precision)
```
  - toHours
```
public static java.math.BigDecimal toHours(java.lang.Long ts)
```
    Converts a given timespan (in seconds) to hours and returns a BigDecimal.
  - toHours
```
public static java.math.BigDecimal toHours(java.lang.Long ts,
                                           int precision)
```
  - toZonedDateTime
```
public static java.time.ZonedDateTime toZonedDateTime(java.util.Date d)
```
    Helper method for a quick conversion from Date to ZonedDateTime, either with an explicit or implicit (system default) time zone. May be replaced by ZonedDateTime.ofInstant() when Java9 is available.
  - toZonedDateTime
```
public static java.time.ZonedDateTime toZonedDateTime(java.util.Date d,
                                                      java.time.ZoneId timezone)
```
  - toLocalDate
```
public static java.time.LocalDate toLocalDate(java.util.Date d)
```
    Helper method for a quick conversion from Date to LocalDate, either with an explicit or implicit (system default) time zone. May be replaced by LocalDate.ofInstant() when Java9 is available.
  - toLocalDate
```
public static java.time.LocalDate toLocalDate(java.util.Date d,
                                              java.time.ZoneId timezone)
```
  - toLocalTime
```
public static java.time.LocalTime toLocalTime(java.util.Date d)
```
    Helper method for a quick conversion from Date to LocalTime, either with an explicit or implicit (system default) time zone. May be replaced by LocalTime.ofInstant() when Java9 is available.
  - toLocalTime
```
public static java.time.LocalTime toLocalTime(java.util.Date d,
                                              java.time.ZoneId timezone)
```
  - toLocalDateTime
```
public static java.time.LocalDateTime toLocalDateTime(java.util.Date d)
```
    Helper method for a quick conversion from Date to LocalDateTime, either with an explicit or implicit (system default) time zone. May be replaced by LocalDateTime.ofInstant() when Java9 is available.
  - toLocalDateTime
```
public static java.time.LocalDateTime toLocalDateTime(java.util.Date d,
                                                      java.time.ZoneId timezone)
```
  - toOffsetDateTime
```
public static java.time.OffsetDateTime toOffsetDateTime(java.util.Date d)
```
    Helper method for a quick conversion from Date to OffsetDateTime, either with an explicit or implicit (system default) time zone. May be replaced by OffsetDateTime.ofInstant() when Java9 is available.
  - toOffsetDateTime
```
public static java.time.OffsetDateTime toOffsetDateTime(java.util.Date d,
                                                        java.time.ZoneId timezone)
```
  - getHoursPerYear
```
public static int getHoursPerYear(int year)
```
    Returns the number of hours in a given year, regarding if it is a leap-year or not.
  - getDaysPerYear
```
public static int getDaysPerYear(int year)
```
    Returns the number of days in a given year, regarding if it is a leap-year or not.
  - getDaysPerMonth
```
public static int getDaysPerMonth(java.util.Date d)
```
    returns the number of days of the month of the given date
    
    Parameters:
    
    d - the date you want the number of days of
    
    Returns:
    
    the number of days, -1 if date is null
  - getDaysPerMonth
```
public static int getDaysPerMonth(int year,
                                  int month)
```
    returns the number of days of the given month in the given year
    
    Parameters:
    
    month - the month of which you want the number of days of
    
    year - the year this month lies in
    
    Returns:
    
    the number of days, -1 if month is invalid number (not 1-12)
  - countDaysInYears
```
public static long countDaysInYears(int yearFrom,
                                    int yearTo)
```
    Returns the number of days in a given year-range, regarding if there are leap-years.
  - coveredTimespanToDays
```
public static int coveredTimespanToDays(TimespanI ts)
```
    Returns the timespan between the passed Date objects, converted to days, default rounded up.
    
    Parameters:
    
    ts - the TimespanI to count the days in
    
    roundUp - if true the number of days is rounded up, defaults to true
    
    Returns:
    
    the timespan between both given date objects converted to days (default rounded up)
  - coveredTimespanToDays
```
public static int coveredTimespanToDays(TimespanI ts,
                                        boolean roundUp)
```
  - coveredTimespanToDays
```
public static int coveredTimespanToDays(java.util.Date d1,
                                        java.util.Date d2)
```
    Returns the timespan between the passed Date objects, converted to days, default rounded up.
    
    Parameters:
    
    ts - the TimespanI to count the days in
    
    d1 - the start date of the timespan
    
    d2 - the end date of the timespan
    
    roundUp - if true the number of days is rounded up, defaults to true
    
    Returns:
    
    the timespan between both given date objects converted to days (default rounded up)
  - coveredTimespanToDays
```
public static int coveredTimespanToDays(java.util.Date d1,
                                        java.util.Date d2,
                                        boolean roundUp)
```
  - countDays
```
public static int countDays(TimespanI ts)
```
    Counts the days covered by the passed TimespanI, ignoring time.
    
    Parameters:
    
    ts - the TimespanI to count the days in
    
    Returns:
    
    the number of days covered by the passed TimespanI, ignoring time
  - countDays
```
public static int countDays(java.util.Date d1,
                            java.util.Date d2)
```
    Counts the days between the dates, including the first, and including the last, ignoring time.
    
    Parameters:
    
    d1 - the date to start from, ignoring time
    
    d2 - the date to end at, ignoring time
    
    Returns:
    
    the number of days passed between the dates, ignoring time
  - coveredTimespanInFullMinutes
```
public static long coveredTimespanInFullMinutes(java.util.Date d1,
                                                java.util.Date d2)
```
    Returns the number of minutes that the passed Date objects cover, rounded down.
    
    Parameters:
    
    d1 - the start date of the timespan
    
    d2 - the end date of the timespan
    
    Returns:
    
    the timespan between both given date objects in minutes
  - coveredTimespanToDays
```
public static int coveredTimespanToDays(java.util.Calendar c1,
                                        java.util.Calendar c2)
```
    Returns the timespan between the passed Calendar objects, converted to days, default rounded up.
    
    Parameters:
    
    c1 - the start date as calendar object to calculate timespan
    
    c2 - the end date as calendar object to calculate timespan
    
    roundUp - if true the number of days is rounded up, defaults to true
    
    Returns:
    
    the timespan between both given Calendar objects converted to days (default rounded up)
  - coveredTimespanToDays
```
public static int coveredTimespanToDays(java.util.Calendar c1,
                                        java.util.Calendar c2,
                                        boolean roundUp)
```
  - getNumberOfMonths
```
public static int getNumberOfMonths(java.util.Date from,
                                    java.util.Date till)
```
    Returns the number of months that the passed Date objects cover, rounded up
    
    Parameters:
    
    from - the start date of the timespan
    
    till - the end date of the timespan
    
    Returns:
    
    the timespan between both given date objects in months (rounded up)
  - getNumberOfMonths
```
public static int getNumberOfMonths(java.util.Calendar c1,
                                    java.util.Calendar c2)
```
    Returns the number of months that the passed Calendar objects cover, rounded up
    
    Parameters:
    
    c1 - the start date of the timespan as calendar object
    
    c2 - the end date of the timespan as calendar object
    
    Returns:
    
    the timespan between both given date objects in months (rounded up)
  - getFractionOfMonth
```
public static java.math.BigDecimal getFractionOfMonth(java.util.Date startDayInMonth,
                                                      java.util.Date endDayInMonth)
```
    Calculates and returns the fraction of a month covered by the given Dates, based on number of days covered. The time in the passed Date objects is neglected.
    
    Parameters:
    
    startDayInMonth - the start date of the timespan to calculate the month fraction for
    
    endDay - the end date of the timespan to calculate the month fraction for
    
    precision - the desired precision of the month fraction to calculate, defaults to 10
    
    Returns:
    
    the fraction of a month covered by the given Dates, based on number of days covered
  - getFractionOfMonth
```
public static java.math.BigDecimal getFractionOfMonth(java.util.Date startDayInMonth,
                                                      java.util.Date endDayInMonth,
                                                      int precision)
```
  - getFirstDayOfYear
```
public static java.util.Date getFirstDayOfYear(int year)
```
    Returns a Date object representing the first day of the passed year, stripped of time.
  - getLastDayOfYear
```
public static java.util.Date getLastDayOfYear(int year)
```
    Returns a Date object representing the last day of the year represented by the passed int, stripped of time.
  - getFirstDayOfYear
```
public static java.util.Date getFirstDayOfYear(java.util.Date d)
```
    Returns a Date object representing the first day of the year of the passed Date, stripped of time.
  - getFirstDayOfCurrentYear
```
public static java.util.Date getFirstDayOfCurrentYear()
```
    Returns a Date object representing the first day of the current year, stripped of time.
  - getLastDayOfYear
```
public static java.util.Date getLastDayOfYear(java.util.Date d)
```
    Returns a Date object representing the last day of the year of the passed date, stripped of time.
  - getNumberOfTouchedYears
```
public static int getNumberOfTouchedYears(java.util.Date start,
                                          java.util.Date stop)
```
    Returns the number of years the passed dates touch. E.g. 2014-03-01 and 2016-02-15 returns 3.
  - getFirstDayOfMonth
```
public static java.util.Date getFirstDayOfMonth(java.util.Date d)
```
    Returns a Date object representing the first day of the month of the given date.
    
    Parameters:
    
    stripTime - if true the returned date has no time, i.e. 00:00, otherwise the time of the passed date is preserved; defaults to true
  - getFirstDayOfMonth
```
public static java.util.Date getFirstDayOfMonth(java.util.Date d,
                                                boolean stripTime)
```
  - getFirstDayOfPreviousMonth
```
public static java.util.Date getFirstDayOfPreviousMonth(java.util.Date d)
```
    Returns a Date object representing the first day of the month before the given date.
    
    Parameters:
    
    stripTime - if true the returned date has no time, i.e. 00:00, otherwise the time of the passed date is preserved; defaults to true
  - getFirstDayOfPreviousMonth
```
public static java.util.Date getFirstDayOfPreviousMonth(java.util.Date d,
                                                        boolean stripTime)
```
  - getFirstDayOfNextMonth
```
public static java.util.Date getFirstDayOfNextMonth(java.util.Date d)
```
    Returns a Date object representing the first day of the month after the given date.
    
    Parameters:
    
    stripTime - if true the returned date has no time, i.e. 00:00, otherwise the time of the passed date is preserved; defaults to true
  - getFirstDayOfNextMonth
```
public static java.util.Date getFirstDayOfNextMonth(java.util.Date d,
                                                    boolean stripTime)
```
  - isFirstDayOfMonth
```
public static boolean isFirstDayOfMonth(java.util.Date d)
```
    Returns true if the passed date is on the first day of the respective month
    
    Parameters:
    
    d - The date to check.
  - getLastDayOfMonth
```
public static java.util.Date getLastDayOfMonth(java.util.Date d)
```
    Returns a Date being the last day of month and year of the given date.
    
    Parameters:
    
    stripTime - if true the returned date has no time, i.e. 00:00, otherwise the time of the passed date is preserved; default to true
  - getLastDayOfMonth
```
public static java.util.Date getLastDayOfMonth(java.util.Date d,
                                               boolean stripTime)
```
  - getLastDayOfPreviousMonth
```
public static java.util.Date getLastDayOfPreviousMonth(java.util.Date d)
```
    Returns a Date object representing the last day of the month before the given date.
    
    Parameters:
    
    stripTime - if true the returned date has no time, i.e. 00:00, otherwise the time of the passed date is preserved; defaults to true
  - getLastDayOfPreviousMonth
```
public static java.util.Date getLastDayOfPreviousMonth(java.util.Date d,
                                                       boolean stripTime)
```
  - getLastDayOfNextMonth
```
public static java.util.Date getLastDayOfNextMonth(java.util.Date d)
```
    Returns a Date object representing the last day of the month after the given date.
    
    Parameters:
    
    stripTime - if true the returned date has no time, i.e. 00:00, otherwise the time of the passed date is preserved; defaults to true
  - getLastDayOfNextMonth
```
public static java.util.Date getLastDayOfNextMonth(java.util.Date d,
                                                   boolean stripTime)
```
  - isLastDayOfMonth
```
public static boolean isLastDayOfMonth(java.util.Date d)
```
    Returns true if the passed date is on the last day of the respective month
    
    Parameters:
    
    d - The date to check.
  - isLastDayOfMonth
```
public static boolean isLastDayOfMonth(java.util.Calendar cal)
```
    Returns true if the passed Calendar represents the last day of the respective month
    
    Parameters:
    
    cal - The Calendar to check.
  - isFirstDayOfYear
```
public static boolean isFirstDayOfYear(java.util.Date d)
```
    Returns true if the passed date is the first day of the year
    
    Parameters:
    
    d - The date to check.
  - isLastDayOfYear
```
public static boolean isLastDayOfYear(java.util.Date d)
```
    Returns true if the passed date represents the last day of its year
    
    Parameters:
    
    d - The date to check.
  - getTimeZoneChangesIn1Day
```
public static long getTimeZoneChangesIn1Day(java.util.Date d)
```
    Uses the java time framework to decide if there is a change of time offset compared to UTC, i.e. from summer to winter time on that date or vice versa. Uses the system default zone by default.
    
    Parameters:
    
    the - date to check of a time zone change for, nonnull. Uses the current system default time zone by default.
    
    Returns:
    
    0 if no zeitumstellung occurs, a negative value if the local clock is 'turned back', e.g. Summer to Winter time. a positive value if the local clock is turned forward. All returned values are in seconds the time zone changes in, e.g. 3600 for one hour.
  - getTimeZoneChangesIn1Day
```
public static long getTimeZoneChangesIn1Day(java.time.ZonedDateTime zdtstart)
```
    Method checks if there is a time zone change between the provided datetime and the datetime 1 day later.
  - getIstZeitumstellungWinterNachSommer
```
public static boolean getIstZeitumstellungWinterNachSommer(java.util.Date d)
```
    Returns:
    
    true if there is a time zone change of 1 hour forward between 00:00 and 24:00 on that day, false otherwise.
  - getIstZeitumstellungSommerNachWinter
```
public static boolean getIstZeitumstellungSommerNachWinter(java.util.Date d)
```
    Returns:
    
    true if there is a time zone change of 1 hour backward between 00:00 and 24:00 on that day, false otherwise
  - getDateWithoutTime
```
public static java.util.Calendar getDateWithoutTime(java.util.Calendar c)
```
    Returns a copy of the passed Calendar, stripped of its time
    
    Parameters:
    
    c - the calendar to copy
    
    Returns:
    
    the calendar with the time stripped of
  - getTimeWithoutDate
```
public static java.util.Calendar getTimeWithoutDate(java.util.Calendar c)
```
    Returns a copy of the passed Calendar, stripped of its date
    
    Parameters:
    
    c - the calendar to copy
    
    Returns:
    
    the calendar with the date stripped of
  - stripTime
```
public static java.util.Date stripTime(java.util.Date d)
```
    Returns a copy of the passed Date, stripped of its time
    
    Parameters:
    
    d - the date to copy
    
    Returns:
    
    the date with the time stripped of
  - stripDate
```
public static java.util.Date stripDate(java.util.Date d)
```
    Returns a copy of the passed Date, stripped of its date
    
    Parameters:
    
    d - the date to copy
    
    Returns:
    
    the date with the date stripped off
  - stripTime
```
public static java.util.Calendar stripTime(java.util.Calendar c)
```
    Returns the passed Calendar, stripped of its time
    
    Parameters:
    
    c - the calendar to copy
    
    Returns:
    
    the calendar with the time stripped of
  - stripDate
```
public static java.util.Calendar stripDate(java.util.Calendar c)
```
    Returns the passed Calendar, stripped of its date
    
    Parameters:
    
    c - the calendar to copy
    
    Returns:
    
    the calendar with the date stripped of
  - stripMinutes
```
public static java.util.Date stripMinutes(java.util.Date _d)
```
    Returns a copy of the passed Date, stripped off its minutes
    
    Parameters:
    
    _d - the date to copy
    
    Returns:
    
    the date with the minutes stripped of
  - stripSeconds
```
public static java.util.Date stripSeconds(java.util.Date _d)
```
    Returns a copy of the passed Date, stripped off its seconds
    
    Parameters:
    
    _d - the date to copy
    
    Returns:
    
    the date with the seconds stripped of
  - stripMillis
```
public static java.util.Date stripMillis(java.util.Date _d)
```
    Returns a copy of the passed Date, stripped off its milliseconds
    
    Parameters:
    
    _d - the date to copy
    
    Returns:
    
    the date with the milliseconds stripped of
  - stripX
```
public static java.util.Date stripX(java.util.Date _d,
                                    java.lang.String _mode)
```
    Returns a copy of the passed Date, stripped of dateparts defined via _mode delegates to stripX(_c = Calendar, _mode = String), for that _mode can have the following values: STRIP_MILLISECONDS STRIP_SECONDS STRIP_MINUTES STRIP_HOURS STRIP_DAYS STRIP_MONTHS STRIP_YEARS STRIP_TIME STRIP_DATE FIXME! Giving STRIP_MONTHS or STRIP_DAYS (and maybe others) will also strip the time part; is this intentional?
    
    Parameters:
    
    _d - the date to copy, nullable.
    
    _mode - the part of the date to strip of
    
    Returns:
    
    the date stripped of the defined part or the original date if the mode could not be recognized. null if the provided date was null.
  - stripX
```
public static java.util.Calendar stripX(java.util.Calendar _c,
                                        java.lang.String _mode)
```
    Returns the passed Calendar, stripped of calendarparts defined via _mode _mode can have the following values: STRIP_MILLISECONDS STRIP_SECONDS STRIP_MINUTES STRIP_HOURS STRIP_DAYS STRIP_MONTHS STRIP_YEARS STRIP_TIME STRIP_DATE
    
    Parameters:
    
    _c - the calendar to copy
    
    _mode - the part of the calendar to strip
    
    Returns:
    
    the calendar stripped of the defined part, or the original calendar if an unrecognized string is used
  - joinDates
```
public static java.util.Date joinDates(java.util.Date _date,
                                       java.util.Date _time)
```
    Returns a Date object with the date of the 1st passed object and the time of the 2nd passed object
    
    Parameters:
    
    _date - the date take date part from
    
    _time - the date take time part from
    
    Returns:
    
    the date with the merged date / time values
  - getNumberOfMillis
```
public static java.lang.Long getNumberOfMillis(java.util.Date d1,
                                               java.util.Date d2)
```
    Returns the number of milliseconds that the passed Date objects cover
    
    Parameters:
    
    d1 - the start date to calculate timespan
    
    d2 - the end date to calculate timespan
    
    Returns:
    
    the timespan between both given date objects in milliseconds
  - getDateObjects
```
public static java.util.List<java.util.Date> getDateObjects(java.util.Date from,
                                                            java.util.Date till)
```
    Returns a List of Date objects for a period between from and till parameters. Corresponds to the groovy method (from..till).toList(). e.g. from = L10n.parseISODate('2023-02-01') till = L10n.parseISODate('2023-02-05') result: [2023-02-01 00:00:00, 2023-02-02 00:00:00, 2023-02-03 00:00:00, 2023-02-04 00:00:00, 2023-02-05 00:00:00] or from = L10n.parseISODate('2023-02-01 22:20:00) till = L10n.parseISODate('2023-03-05 01:43:25') result: [2023-02-01 22:20:00, 2023-02-02 22:20:00, 2023-02-03 22:20:00, 2023-02-04 22:20:00]
    
    Parameters:
    
    from - start date
    
    till - end date
    
    Returns:
    
    List of Date objects
  - getFormatsWithExamples
```
public static java.util.List<java.lang.String> getFormatsWithExamples(java.util.Collection<java.lang.String> formats)
```
    Returns a list of date format strings along with examples of the current date formatted according to each of these formats.
    This method is designed to be user-friendly by not only providing the formats but also showing a valid input string for the current date in each format. This can help users understand how to use each format correctly.
    
    Parameters:
    
    formats - a collection of date format strings to be demonstrated with examples.
    
    Returns:
    
    a list of strings where each string includes a date format and an example of the current date in that format. The format of each string in the list is: "- ()"

Class DateTimeTools

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DATEFORMAT_PATTERN

MILLISECONDS_PER_SECOND

SECONDS_PER_MINUTE

MILLISECONDS_PER_MINUTE

MINUTES_PER_HOUR

SECONDS_PER_HOUR

MILLISECONDS_PER_HOUR

HOURS_PER_DAY

MINUTES_PER_DAY

SECONDS_PER_DAY

MILLISECONDS_PER_DAY

STRIP_MILLISECONDS

STRIP_SECONDS

STRIP_MINUTES

STRIP_HOURS

STRIP_DAYS

STRIP_MONTHS

STRIP_YEARS

STRIP_TIME

STRIP_DATE

Method Detail

getDate

getMonthsList

getMonthsList

getMonthsList

liesInLeftOpenInterval

liesInLeftOpenInterval

liesInLeftOpenInterval

liesInRightOpenInterval

liesInRightOpenInterval

liesInRightOpenInterval

liesInOpenInterval

liesInOpenInterval

liesInOpenInterval

liesInInterval

liesInInterval

liesInInterval

liesInLeftOpenInterval

liesInLeftOpenInterval

liesInLeftOpenInterval

liesInRightOpenInterval

liesInRightOpenInterval

liesInRightOpenInterval

liesInOpenInterval

liesInOpenInterval

liesInOpenInterval

liesInInterval

liesInInterval

liesInInterval

liesInInterval

liesInInterval

overlap

overlap

overlaps

checkTimespan

createCalendar

createCalendar

createCalendar

nullSafeBefore

nullSafeAfter

isBeforeOrSameDate

isAfterOrSameDate

isBeforeOrSameDate

isAfterOrSameDate

isSameDayOfWeek

isBeforeOrSameDay

isBeforeOrSameDay

isAfterOrSameDay

isAfterOrSameDay

isNextDay

isSameDay

isPreviousDay

isMonth

isSameMonth

isSameYear