[BAEL-18364] move spring-rest-*** articles - 1

java-dates/src/main/java/com/baeldung/date/AgeCalculator.java

@@ -0,0 +1,32 @@
+package com.baeldung.date;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.Date;
+import org.joda.time.Years;
+
+public class AgeCalculator {
+
+    public int calculateAge(LocalDate birthDate, LocalDate currentDate) {
+        // validate inputs ...
+        return Period.between(birthDate, currentDate)
+            .getYears();
+    }
+
+    public int calculateAgeWithJodaTime(org.joda.time.LocalDate birthDate, org.joda.time.LocalDate currentDate) {
+        // validate inputs ...
+        Years age = Years.yearsBetween(birthDate, currentDate);
+        return age.getYears();
+    }
+
+    public int calculateAgeWithJava7(Date birthDate, Date currentDate) {
+        // validate inputs ...
+        DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
+        int d1 = Integer.parseInt(formatter.format(birthDate));
+        int d2 = Integer.parseInt(formatter.format(currentDate));
+        int age = (d2 - d1) / 10000;
+        return age;
+    }
+}

java-dates/src/main/java/com/baeldung/date/DateWithoutTime.java

@@ -0,0 +1,30 @@
+package com.baeldung.date;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+
+public class DateWithoutTime {
+
+    public static Date getDateWithoutTimeUsingCalendar() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+
+        return calendar.getTime();
+    }
+
+    public static Date getDateWithoutTimeUsingFormat() throws ParseException {
+        SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
+        return formatter.parse(formatter.format(new Date()));
+    }
+
+    public static LocalDate getLocalDate() {
+        return LocalDate.now();
+    }
+
+}

java-dates/src/main/java/com/baeldung/datetime/AddHoursToDate.java

@@ -0,0 +1,54 @@
+package com.baeldung.datetime;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.apache.commons.lang3.time.DateUtils;
+
+public class AddHoursToDate {
+
+    public Date addHoursToJavaUtilDate(Date date, int hours) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.add(Calendar.HOUR_OF_DAY, hours);
+        return calendar.getTime();
+    }
+
+    public Date addHoursToDateUsingInstant(Date date, int hours) {
+        return Date.from(date.toInstant()
+            .plus(Duration.ofHours(hours)));
+    }
+
+    public LocalDateTime addHoursToLocalDateTime(LocalDateTime localDateTime, int hours) {
+        return localDateTime.plusHours(hours);
+    }
+
+    public LocalDateTime subtractHoursToLocalDateTime(LocalDateTime localDateTime, int hours) {
+        return localDateTime.minusHours(hours);
+    }
+
+    public ZonedDateTime addHoursToZonedDateTime(ZonedDateTime zonedDateTime, int hours) {
+        return zonedDateTime.plusHours(hours);
+    }
+
+    public ZonedDateTime subtractHoursToZonedDateTime(ZonedDateTime zonedDateTime, int hours) {
+        return zonedDateTime.minusHours(hours);
+    }
+
+    public Instant addHoursToInstant(Instant instant, int hours) {
+        return instant.plus(hours, ChronoUnit.HOURS);
+    }
+
+    public Instant subtractHoursToInstant(Instant instant, int hours) {
+        return instant.minus(hours, ChronoUnit.HOURS);
+    }
+
+    public Date addHoursWithApacheCommons(Date date, int hours) {
+        return DateUtils.addHours(date, hours);
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/DateExtractYearMonthDayIntegerValues.java

@@ -0,0 +1,28 @@
+package com.baeldung.datetime;
+
+import java.util.Calendar;
+import java.util.Date;
+
+public class DateExtractYearMonthDayIntegerValues {
+
+    int getYear(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        return calendar.get(Calendar.YEAR);
+    }
+
+    int getMonth(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        return calendar.get(Calendar.MONTH);
+    }
+
+    int getDay(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        return calendar.get(Calendar.DAY_OF_MONTH);
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/LocalDateExtractYearMonthDayIntegerValues.java

@@ -0,0 +1,18 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+
+public class LocalDateExtractYearMonthDayIntegerValues {
+
+    int getYear(LocalDate localDate) {
+        return localDate.getYear();
+    }
+
+    int getMonth(LocalDate localDate) {
+        return localDate.getMonthValue();
+    }
+
+    int getDay(LocalDate localDate) {
+        return localDate.getDayOfMonth();
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/LocalDateTimeExtractYearMonthDayIntegerValues.java

@@ -0,0 +1,18 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+
+public class LocalDateTimeExtractYearMonthDayIntegerValues {
+
+    int getYear(LocalDateTime localDateTime) {
+        return localDateTime.getYear();
+    }
+
+    int getMonth(LocalDateTime localDateTime) {
+        return localDateTime.getMonthValue();
+    }
+
+    int getDay(LocalDateTime localDateTime) {
+        return localDateTime.getDayOfMonth();
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/OffsetDateTimeExtractYearMonthDayIntegerValues.java

@@ -0,0 +1,18 @@
+package com.baeldung.datetime;
+
+import java.time.OffsetDateTime;
+
+public class OffsetDateTimeExtractYearMonthDayIntegerValues {
+
+    int getYear(OffsetDateTime offsetDateTime) {
+        return offsetDateTime.getYear();
+    }
+
+    int getMonth(OffsetDateTime offsetDateTime) {
+        return offsetDateTime.getMonthValue();
+    }
+
+    int getDay(OffsetDateTime offsetDateTime) {
+        return offsetDateTime.getDayOfMonth();
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/README.md

@@ -0,0 +1 @@
+### Relevant Articles:

java-dates/src/main/java/com/baeldung/datetime/UseDuration.java

@@ -0,0 +1,15 @@
+package com.baeldung.datetime;
+
+import java.time.Duration;
+import java.time.LocalTime;
+
+public class UseDuration {
+
+    public LocalTime modifyDates(LocalTime localTime, Duration duration) {
+        return localTime.plus(duration);
+    }
+
+    public Duration getDifferenceBetweenDates(LocalTime localTime1, LocalTime localTime2) {
+        return Duration.between(localTime1, localTime2);
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/UseLocalDate.java

@@ -0,0 +1,73 @@
+package com.baeldung.datetime;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAdjusters;
+
+class UseLocalDate {
+
+    LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth) {
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+
+    LocalDate getLocalDateUsingParseMethod(String representation) {
+        return LocalDate.parse(representation);
+    }
+
+    LocalDate getLocalDateFromClock() {
+        LocalDate localDate = LocalDate.now();
+        return localDate;
+    }
+
+    LocalDate getNextDay(LocalDate localDate) {
+        return localDate.plusDays(1);
+    }
+
+    LocalDate getPreviousDay(LocalDate localDate) {
+        return localDate.minus(1, ChronoUnit.DAYS);
+    }
+
+    DayOfWeek getDayOfWeek(LocalDate localDate) {
+        DayOfWeek day = localDate.getDayOfWeek();
+        return day;
+    }
+
+    LocalDate getFirstDayOfMonth() {
+        LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
+        return firstDayOfMonth;
+    }
+
+    LocalDateTime getStartOfDay(LocalDate localDate) {
+        LocalDateTime startofDay = localDate.atStartOfDay();
+        return startofDay;
+    }
+
+    LocalDateTime getStartOfDayOfLocalDate(LocalDate localDate) {
+        LocalDateTime startofDay = LocalDateTime.of(localDate, LocalTime.MIDNIGHT);
+        return startofDay;
+    }
+
+    LocalDateTime getStartOfDayAtMinTime(LocalDate localDate) {
+        LocalDateTime startofDay = localDate.atTime(LocalTime.MIN);
+        return startofDay;
+    }
+
+    LocalDateTime getStartOfDayAtMidnightTime(LocalDate localDate) {
+        LocalDateTime startofDay = localDate.atTime(LocalTime.MIDNIGHT);
+        return startofDay;
+    }
+
+    LocalDateTime getEndOfDay(LocalDate localDate) {
+        LocalDateTime endOfDay = localDate.atTime(LocalTime.MAX);
+        return endOfDay;
+    }
+
+    LocalDateTime getEndOfDayFromLocalTime(LocalDate localDate) {
+        LocalDateTime endOfDate = LocalTime.MAX.atDate(localDate);
+        return endOfDate;
+    }
+
+}

java-dates/src/main/java/com/baeldung/datetime/UseLocalDateTime.java

@@ -0,0 +1,24 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.temporal.ChronoField;
+
+public class UseLocalDateTime {
+
+    public LocalDateTime getLocalDateTimeUsingParseMethod(String representation) {
+        return LocalDateTime.parse(representation);
+    }
+
+    LocalDateTime getEndOfDayFromLocalDateTimeDirectly(LocalDateTime localDateTime) {
+        LocalDateTime endOfDate = localDateTime.with(ChronoField.NANO_OF_DAY, LocalTime.MAX.toNanoOfDay());
+        return endOfDate;
+    }
+
+    LocalDateTime getEndOfDayFromLocalDateTime(LocalDateTime localDateTime) {
+        LocalDateTime endOfDate = localDateTime.toLocalDate()
+            .atTime(LocalTime.MAX);
+        return endOfDate;
+    }
+
+}

java-dates/src/main/java/com/baeldung/datetime/UseLocalTime.java

@@ -0,0 +1,31 @@
+package com.baeldung.datetime;
+
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+
+public class UseLocalTime {
+
+    LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds) {
+        return LocalTime.of(hour, min, seconds);
+    }
+
+    LocalTime getLocalTimeUsingParseMethod(String timeRepresentation) {
+        return LocalTime.parse(timeRepresentation);
+    }
+
+    private LocalTime getLocalTimeFromClock() {
+        return LocalTime.now();
+    }
+
+    LocalTime addAnHour(LocalTime localTime) {
+        return localTime.plus(1, ChronoUnit.HOURS);
+    }
+
+    int getHourFromLocalTime(LocalTime localTime) {
+        return localTime.getHour();
+    }
+
+    LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute) {
+        return localTime.withMinute(minute);
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/UsePeriod.java

@@ -0,0 +1,15 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+class UsePeriod {
+
+    LocalDate modifyDates(LocalDate localDate, Period period) {
+        return localDate.plus(period);
+    }
+
+    Period getDifferenceBetweenDates(LocalDate localDate1, LocalDate localDate2) {
+        return Period.between(localDate1, localDate2);
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/UseToInstant.java

@@ -0,0 +1,17 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Calendar;
+import java.util.Date;
+
+public class UseToInstant {
+
+    public LocalDateTime convertDateToLocalDate(Date date) {
+        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
+    }
+
+    public LocalDateTime convertDateToLocalDate(Calendar calendar) {
+        return LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault());
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/UseZonedDateTime.java

@@ -0,0 +1,42 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoField;
+
+class UseZonedDateTime {
+
+    ZonedDateTime getZonedDateTime(LocalDateTime localDateTime, ZoneId zoneId) {
+        return ZonedDateTime.of(localDateTime, zoneId);
+    }
+
+    ZonedDateTime getStartOfDay(LocalDate localDate, ZoneId zone) {
+        ZonedDateTime startofDay = localDate.atStartOfDay()
+            .atZone(zone);
+        return startofDay;
+    }
+
+    ZonedDateTime getStartOfDayShorthand(LocalDate localDate, ZoneId zone) {
+        ZonedDateTime startofDay = localDate.atStartOfDay(zone);
+        return startofDay;
+    }
+
+    ZonedDateTime getStartOfDayFromZonedDateTime(ZonedDateTime zonedDateTime) {
+        ZonedDateTime startofDay = zonedDateTime.toLocalDateTime()
+            .toLocalDate()
+            .atStartOfDay(zonedDateTime.getZone());
+        return startofDay;
+    }
+
+    ZonedDateTime getStartOfDayAtMinTime(ZonedDateTime zonedDateTime) {
+        ZonedDateTime startofDay = zonedDateTime.with(ChronoField.HOUR_OF_DAY, 0);
+        return startofDay;
+    }
+
+    ZonedDateTime getStartOfDayAtMidnightTime(ZonedDateTime zonedDateTime) {
+        ZonedDateTime startofDay = zonedDateTime.with(ChronoField.NANO_OF_DAY, 0);
+        return startofDay;
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/ZonedDateTimeExtractYearMonthDayIntegerValues.java

@@ -0,0 +1,18 @@
+package com.baeldung.datetime;
+
+import java.time.ZonedDateTime;
+
+public class ZonedDateTimeExtractYearMonthDayIntegerValues {
+
+    int getYear(ZonedDateTime zonedDateTime) {
+        return zonedDateTime.getYear();
+    }
+
+    int getMonth(ZonedDateTime zonedDateTime) {
+        return zonedDateTime.getMonthValue();
+    }
+
+    int getDay(ZonedDateTime zonedDateTime) {
+        return zonedDateTime.getDayOfMonth();
+    }
+}

java-dates/src/main/java/com/baeldung/datetime/modify/DateIncrementer.java

@@ -0,0 +1,63 @@
+package com.baeldung.datetime.modify;
+
+import org.apache.commons.lang3.time.DateUtils;
+import org.joda.time.DateTime;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.logging.Logger;
+
+public class DateIncrementer {
+    private static final Logger log = Logger.getLogger(DateIncrementer.class.getName());
+    private static final int INCREMENT_BY_IN_DAYS = 1;
+
+    public static String addOneDay(String date) {
+        return LocalDate
+          .parse(date)
+          .plusDays(INCREMENT_BY_IN_DAYS)
+          .toString();
+    }
+
+    public static String addOneDayJodaTime(String date) {
+        DateTime dateTime = new DateTime(date);
+        return dateTime
+          .plusDays(INCREMENT_BY_IN_DAYS)
+          .toString("yyyy-MM-dd");
+    }
+
+    public static String addOneDayCalendar(String date) throws ParseException {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        Calendar c = Calendar.getInstance();
+        c.setTime(sdf.parse(date));
+        c.add(Calendar.DATE, 1);
+        return sdf.format(c.getTime());
+    }
+
+    public static String addOneDayApacheCommons(String date) throws ParseException {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        Date incrementedDate = DateUtils.addDays(sdf.parse(date), 1);
+        return sdf.format(incrementedDate);
+    }
+
+    public static void main(String[] args) throws ParseException {
+        String date = LocalDate
+          .now()
+          .toString();
+        log.info("Current date = " + date);
+
+        String incrementedDateJava8 = DateIncrementer.addOneDay(date);
+        log.info("Date incremented by one day using (Java 8): " + incrementedDateJava8);
+
+        String incrementedDateJodaTime = DateIncrementer.addOneDayJodaTime(date);
+        log.info("Date incremented by one day using (Joda-Time): " + incrementedDateJodaTime);
+
+        String incrementedDateCalendar = addOneDayCalendar(date);
+        log.info("Date incremented by one day using (java.util.Calendar): " + incrementedDateCalendar);
+
+        String incrementedDateApacheCommons = addOneDayApacheCommons(date);
+        log.info("Date incremented by one day using (Apache Commons DateUtils): " + incrementedDateApacheCommons);
+    }
+}

java-dates/src/main/java/com/baeldung/datetolocaldate/DateToLocalDateConverter.java

@@ -0,0 +1,39 @@
+/**
+ * 
+ */
+package com.baeldung.datetolocaldate;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows a way to convert java.util.Date into java.time.LocalDate.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateConverter {
+
+    public static LocalDate convertToLocalDateViaInstant(Date dateToConvert) {
+        return dateToConvert.toInstant()
+            .atZone(ZoneId.systemDefault())
+            .toLocalDate();
+    }
+
+    public static LocalDate convertToLocalDateViaSqlDate(Date dateToConvert) {
+        return new java.sql.Date(dateToConvert.getTime()).toLocalDate();
+    }
+
+    public static LocalDate convertToLocalDateViaMilisecond(Date dateToConvert) {
+        return Instant.ofEpochMilli(dateToConvert.getTime())
+            .atZone(ZoneId.systemDefault())
+            .toLocalDate();
+    }
+
+    public static LocalDate convertToLocalDate(Date dateToConvert) {
+        return LocalDate.ofInstant(dateToConvert.toInstant(), ZoneId.systemDefault());
+    }
+
+}

java-dates/src/main/java/com/baeldung/datetolocaldate/DateToLocalDateTimeConverter.java

@@ -0,0 +1,39 @@
+/**
+ * 
+ */
+package com.baeldung.datetolocaldate;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows a way to convert java.util.Date into java.time.LocalDateTime.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateTimeConverter {
+
+    public static LocalDateTime convertToLocalDateTimeViaInstant(Date dateToConvert) {
+        return dateToConvert.toInstant()
+            .atZone(ZoneId.systemDefault())
+            .toLocalDateTime();
+    }
+
+    public static LocalDateTime convertToLocalDateTimeViaSqlTimestamp(Date dateToConvert) {
+        return new java.sql.Timestamp(dateToConvert.getTime()).toLocalDateTime();
+    }
+
+    public static LocalDateTime convertToLocalDateTimeViaMilisecond(Date dateToConvert) {
+        return Instant.ofEpochMilli(dateToConvert.getTime())
+            .atZone(ZoneId.systemDefault())
+            .toLocalDateTime();
+    }
+
+    public static LocalDateTime convertToLocalDateTime(Date dateToConvert) {
+        return LocalDateTime.ofInstant(dateToConvert.toInstant(), ZoneId.systemDefault());
+    }
+
+}

java-dates/src/main/java/com/baeldung/datetolocaldate/LocalDateTimeToDateConverter.java

@@ -0,0 +1,27 @@
+/**
+ * 
+ */
+package com.baeldung.datetolocaldate;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows different ways of converting java.time.LocalDateTime into java.util.Date. 
+ *  
+ * @author abialas
+ *
+ */
+public class LocalDateTimeToDateConverter {
+
+    public static Date convertToDateViaSqlTimestamp(LocalDateTime dateToConvert) {
+        return java.sql.Timestamp.valueOf(dateToConvert);
+    }
+
+    public static Date convertToDateViaInstant(LocalDateTime dateToConvert) {
+        return java.util.Date.from(dateToConvert.atZone(ZoneId.systemDefault())
+            .toInstant());
+    }
+
+}

java-dates/src/main/java/com/baeldung/datetolocaldate/LocalDateToDateConverter.java

@@ -0,0 +1,28 @@
+/**
+ * 
+ */
+package com.baeldung.datetolocaldate;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows different ways of converting java.time.LocalDate into java.util.Date. 
+ *  
+ * @author abialas
+ *
+ */
+public class LocalDateToDateConverter {
+
+    public static Date convertToDateViaSqlDate(LocalDate dateToConvert) {
+        return java.sql.Date.valueOf(dateToConvert);
+    }
+
+    public static Date convertToDateViaInstant(LocalDate dateToConvert) {
+        return java.util.Date.from(dateToConvert.atStartOfDay()
+            .atZone(ZoneId.systemDefault())
+            .toInstant());
+    }
+
+}

java-dates/src/main/java/com/baeldung/gregorian/calendar/GregorianCalendarExample.java

@@ -0,0 +1,69 @@
+package com.baeldung.gregorian.calendar;
+
+import java.time.format.DateTimeFormatter;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+import java.util.TimeZone;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+public class GregorianCalendarExample {
+
+   
+    public Date setMonth(GregorianCalendar calendar, int amount) {
+        calendar.set(Calendar.MONTH, amount);
+        return calendar.getTime();
+    }
+
+   
+    public Date rollAdd(GregorianCalendar calendar, int amount) {
+        calendar.roll(GregorianCalendar.MONTH, amount);
+        return calendar.getTime();
+    }
+
+    public  boolean isLeapYearExample(int year) {
+        GregorianCalendar cal = (GregorianCalendar) GregorianCalendar.getInstance();
+        return cal.isLeapYear(year);
+    }
+
+
+
+    public Date subtractDays(GregorianCalendar calendar, int daysToSubtract) {
+        GregorianCalendar cal = calendar;
+        cal.add(Calendar.DATE, -daysToSubtract);
+        return cal.getTime();
+    }
+
+    public Date addDays(GregorianCalendar calendar, int daysToAdd) {
+        GregorianCalendar cal = calendar;
+        cal.add(Calendar.DATE, daysToAdd);
+        return cal.getTime();
+    }
+
+    public XMLGregorianCalendar toXMLGregorianCalendar(GregorianCalendar calendar) throws DatatypeConfigurationException {
+        DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
+        return datatypeFactory.newXMLGregorianCalendar(calendar);
+    }
+
+    public Date toDate(XMLGregorianCalendar calendar) {
+        return calendar.toGregorianCalendar()
+            .getTime();
+    }
+
+    public int compareDates(GregorianCalendar firstDate, GregorianCalendar secondDate) {
+        return firstDate.compareTo(secondDate);
+    }
+
+    public String formatDate(GregorianCalendar calendar) {
+        return calendar.toZonedDateTime()
+            .format(DateTimeFormatter.ofPattern("d MMM uuuu"));
+    }
+
+}

java-dates/src/main/java/com/baeldung/java9/time/TimeApi.java

@@ -0,0 +1,43 @@
+package com.baeldung.java9.time;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class TimeApi {
+
+    public static List<Date> getDatesBetweenUsingJava7(Date startDate, Date endDate) {
+        List<Date> datesInRange = new ArrayList<Date>();
+        Calendar calendar = new GregorianCalendar();
+        calendar.setTime(startDate);
+
+        Calendar endCalendar = new GregorianCalendar();
+        endCalendar.setTime(endDate);
+
+        while (calendar.before(endCalendar)) {
+            Date result = calendar.getTime();
+            datesInRange.add(result);
+            calendar.add(Calendar.DATE, 1);
+        }
+        return datesInRange;
+    }
+
+    public static List<LocalDate> getDatesBetweenUsingJava8(LocalDate startDate, LocalDate endDate) {
+        long numOfDaysBetween = ChronoUnit.DAYS.between(startDate, endDate);
+        return IntStream.iterate(0, i -> i + 1)
+                 .limit(numOfDaysBetween)
+                 .mapToObj(i -> startDate.plusDays(i))
+                 .collect(Collectors.toList());
+    }
+
+    public static List<LocalDate> getDatesBetweenUsingJava9(LocalDate startDate, LocalDate endDate) {
+        return startDate.datesUntil(endDate).collect(Collectors.toList());
+    }
+
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/DateMatcher.java

@@ -0,0 +1,7 @@
+package com.baeldung.regexp.datepattern;
+
+public interface DateMatcher {
+
+    boolean matches(String date);
+
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/FormattedDateMatcher.java

@@ -0,0 +1,14 @@
+package com.baeldung.regexp.datepattern;
+
+import java.util.regex.Pattern;
+
+class FormattedDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^\\d{4}-\\d{2}-\\d{2}$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/RangedDateMatcher.java

@@ -0,0 +1,14 @@
+package com.baeldung.regexp.datepattern;
+
+import java.util.regex.Pattern;
+
+class RangedDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((19|2[0-9])[0-9]{2})-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/gregorian/February29thMatcher.java

@@ -0,0 +1,16 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class February29thMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((2000|2400|2800|(19|2[0-9](0[48]|[2468][048]|[13579][26])))-02-29)$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/gregorian/FebruaryGeneralMatcher.java

@@ -0,0 +1,16 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class FebruaryGeneralMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-02-(0[1-9]|1[0-9]|2[0-8]))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/gregorian/GregorianDateMatcher.java

@@ -0,0 +1,19 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+class GregorianDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((2000|2400|2800|(19|2[0-9](0[48]|[2468][048]|[13579][26])))-02-29)$" 
+            + "|^(((19|2[0-9])[0-9]{2})-02-(0[1-9]|1[0-9]|2[0-8]))$"
+            + "|^(((19|2[0-9])[0-9]{2})-(0[13578]|10|12)-(0[1-9]|[12][0-9]|3[01]))$" 
+            + "|^(((19|2[0-9])[0-9]{2})-(0[469]|11)-(0[1-9]|[12][0-9]|30))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf30DaysMatcher.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class MonthsOf30DaysMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-(0[469]|11)-(0[1-9]|[12][0-9]|30))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf31DaysMatcher.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class MonthsOf31DaysMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-(0[13578]|10|12)-(0[1-9]|[12][0-9]|3[01]))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+
+}

java-dates/src/main/java/com/baeldung/regexp/datepattern/optmization/OptimizedMatcher.java

@@ -0,0 +1,6 @@
+package com.baeldung.regexp.datepattern.optmization;
+
+public class OptimizedMatcher {
+
+
+}

java-dates/src/main/java/com/baeldung/temporaladjuster/CustomTemporalAdjuster.java

@@ -0,0 +1,22 @@
+package com.baeldung.temporaladjuster;
+
+import java.time.DayOfWeek;
+import java.time.temporal.ChronoField;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAdjuster;
+
+public class CustomTemporalAdjuster implements TemporalAdjuster {
+
+    @Override
+    public Temporal adjustInto(Temporal temporal) {
+        switch (DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK))) {
+        case FRIDAY:
+            return temporal.plus(3, ChronoUnit.DAYS);
+        case SATURDAY:
+            return temporal.plus(2, ChronoUnit.DAYS);
+        default:
+            return temporal.plus(1, ChronoUnit.DAYS);
+        }
+    }
+}

java-dates/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplay.java

@@ -0,0 +1,55 @@
+package com.baeldung.timezonedisplay;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class TimezoneDisplay {
+
+    public enum OffsetBase {
+        GMT, UTC
+    }
+
+    public List<String> getTimeZoneList(OffsetBase base) {
+        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
+
+        LocalDateTime now = LocalDateTime.now();
+        return availableZoneIds
+          .stream()
+          .map(ZoneId::of)
+          .sorted(new ZoneComparator())
+          .map(id -> String.format("(%s%s) %s", base, getOffset(now, id), id.getId()))
+          .collect(Collectors.toList());
+    }
+
+    private String getOffset(LocalDateTime dateTime, ZoneId id) {
+        return dateTime
+          .atZone(id)
+          .getOffset()
+          .getId()
+          .replace("Z", "+00:00");
+    }
+
+    private class ZoneComparator implements Comparator<ZoneId> {
+
+        @Override
+        public int compare(ZoneId zoneId1, ZoneId zoneId2) {
+            LocalDateTime now = LocalDateTime.now();
+
+            ZoneOffset offset1 = now
+              .atZone(zoneId1)
+              .getOffset();
+
+            ZoneOffset offset2 = now
+              .atZone(zoneId2)
+              .getOffset();
+
+            return offset1.compareTo(offset2);
+        }
+    }
+
+}

java-dates/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplayApp.java

@@ -0,0 +1,18 @@
+package com.baeldung.timezonedisplay;
+
+import java.util.List;
+
+public class TimezoneDisplayApp {
+
+    public static void main(String... args) {
+        TimezoneDisplay display = new TimezoneDisplay();
+
+        System.out.println("Time zones in UTC:");
+        List<String> utc = display.getTimeZoneList(TimezoneDisplay.OffsetBase.UTC);
+        utc.forEach(System.out::println);
+
+        System.out.println("Time zones in GMT:");
+        List<String> gmt = display.getTimeZoneList(TimezoneDisplay.OffsetBase.GMT);
+        gmt.forEach(System.out::println);
+    }
+}

java-dates/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplayJava7.java

@@ -0,0 +1,43 @@
+package com.baeldung.timezonedisplay;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.TimeZone;
+import java.util.concurrent.TimeUnit;
+
+public class TimezoneDisplayJava7 {
+
+    public enum OffsetBase {
+        GMT, UTC
+    }
+
+    public List<String> getTimeZoneList(TimezoneDisplayJava7.OffsetBase base) {
+        String[] availableZoneIds = TimeZone.getAvailableIDs();
+        List<String> result = new ArrayList<>(availableZoneIds.length);
+
+        for (String zoneId : availableZoneIds) {
+            TimeZone curTimeZone = TimeZone.getTimeZone(zoneId);
+
+            String offset = calculateOffset(curTimeZone.getRawOffset());
+
+            result.add(String.format("(%s%s) %s", base, offset, zoneId));
+        }
+
+        Collections.sort(result);
+
+        return result;
+    }
+
+    private String calculateOffset(int rawOffset) {
+        if (rawOffset == 0) {
+            return "+00:00";
+        }
+        long hours = TimeUnit.MILLISECONDS.toHours(rawOffset);
+        long minutes = TimeUnit.MILLISECONDS.toMinutes(rawOffset);
+        minutes = Math.abs(minutes - TimeUnit.HOURS.toMinutes(hours));
+
+        return String.format("%+03d:%02d", hours, Math.abs(minutes));
+    }
+
+}

java-dates/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplayJava7App.java

@@ -0,0 +1,23 @@
+package com.baeldung.timezonedisplay;
+
+import java.util.List;
+
+public class TimezoneDisplayJava7App {
+
+    public static void main(String... args) {
+        TimezoneDisplayJava7 display = new TimezoneDisplayJava7();
+
+        System.out.println("Time zones in UTC:");
+        List<String> utc = display.getTimeZoneList(TimezoneDisplayJava7.OffsetBase.UTC);
+        for (String timeZone : utc) {
+            System.out.println(timeZone);
+        }
+
+        System.out.println("Time zones in GMT:");
+        List<String> gmt = display.getTimeZoneList(TimezoneDisplayJava7.OffsetBase.GMT);
+        for (String timeZone : gmt) {
+            System.out.println(timeZone);
+        }
+    }
+
+}

java-dates/src/main/java/com/baeldung/zoneddatetime/OffsetDateTimeExample.java

@@ -0,0 +1,13 @@
+package com.baeldung.zoneddatetime;
+
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+
+public class OffsetDateTimeExample {
+
+    public OffsetDateTime getCurrentTimeByZoneOffset(String offset) {
+        ZoneOffset zoneOffSet= ZoneOffset.of(offset);
+        OffsetDateTime date = OffsetDateTime.now(zoneOffSet);
+        return date;
+    }
+}

java-dates/src/main/java/com/baeldung/zoneddatetime/OffsetTimeExample.java

@@ -0,0 +1,13 @@
+package com.baeldung.zoneddatetime;
+
+import java.time.OffsetTime;
+import java.time.ZoneOffset;
+
+public class OffsetTimeExample {
+
+    public OffsetTime getCurrentTimeByZoneOffset(String offset) {
+        ZoneOffset zoneOffSet = ZoneOffset.of(offset);
+        OffsetTime time = OffsetTime.now(zoneOffSet);
+        return time;
+    }
+}

java-dates/src/main/java/com/baeldung/zoneddatetime/ZoneDateTimeExample.java

@@ -0,0 +1,21 @@
+package com.baeldung.zoneddatetime;
+
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+public class ZoneDateTimeExample {
+
+    public ZonedDateTime getCurrentTimeByZoneId(String region) {
+        ZoneId zone = ZoneId.of(region);
+        ZonedDateTime date = ZonedDateTime.now(zone);
+        return date;
+    }
+
+    public ZonedDateTime convertZonedDateTime(ZonedDateTime sourceDate, String destZone) {
+
+        ZoneId destZoneId = ZoneId.of(destZone);
+        ZonedDateTime destDate = sourceDate.withZoneSameInstant(destZoneId);
+
+        return destDate;
+    }
+}