Merge remote-tracking branch 'upstream/master'

2018-06-30 00:04:48 +02:00
parent 172642e190 0fd7481bb9
commit 3b1c7ead13
73 changed files with 3717 additions and 106 deletions
@@ -0,0 +1,52 @@
+package com.baeldung.algorithms.romannumerals;
+
+import java.util.List;
+
+class RomanArabicConverter {
+
+    public static int romanToArabic(String input) {
+        String romanNumeral = input.toUpperCase();
+        int result = 0;
+        
+        List<RomanNumeral> romanNumerals = RomanNumeral.getReverseSortedValues();
+
+        int i = 0;
+
+        while ((romanNumeral.length() > 0) && (i < romanNumerals.size())) {
+            RomanNumeral symbol = romanNumerals.get(i);
+            if (romanNumeral.startsWith(symbol.name())) {
+                result += symbol.getValue();
+                romanNumeral = romanNumeral.substring(symbol.name().length());
+            } else {
+                i++;
+            }
+        }
+        if (romanNumeral.length() > 0) {
+            throw new IllegalArgumentException(input + " cannot be converted to a Roman Numeral");
+        }
+
+        return result;
+    }
+
+    public static String arabicToRoman(int number) {
+        if ((number <= 0) || (number > 4000)) {
+            throw new IllegalArgumentException(number + " is not in range (0,4000]");
+        }
+
+        List<RomanNumeral> romanNumerals = RomanNumeral.getReverseSortedValues();
+
+        int i = 0;
+        StringBuilder sb = new StringBuilder();
+
+        while (number > 0 && i < romanNumerals.size()) {
+            RomanNumeral currentSymbol = romanNumerals.get(i);
+            if (currentSymbol.getValue() <= number) {
+                sb.append(currentSymbol.name());
+                number -= currentSymbol.getValue();
+            } else {
+                i++;
+            }
+        }
+        return sb.toString();
+    }
+}
@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.romannumerals;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+enum RomanNumeral {
+    I(1), IV(4), V(5), IX(9), X(10), XL(40), L(50), XC(90), C(100), CD(400), D(500), CM(900), M(1000);
+
+    private int value;
+
+    RomanNumeral(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+    
+    public static List<RomanNumeral> getReverseSortedValues() {
+        return Arrays.stream(values())
+          .sorted(Comparator.comparing((RomanNumeral e) -> e.value).reversed())
+          .collect(Collectors.toList());
+    }
+}
@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.romannumerals;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class RomanArabicConverterUnitTest {
+
+    @Test
+    public void given2018Roman_WhenConvertingToArabic_ThenReturn2018() {
+
+        String roman2018 = "MMXVIII";
+
+        int result = RomanArabicConverter.romanToArabic(roman2018);
+
+        assertThat(result).isEqualTo(2018);
+    }
+
+    @Test
+    public void given1999Arabic_WhenConvertingToRoman_ThenReturnMCMXCIX() {
+
+        int arabic1999 = 1999;
+
+        String result = RomanArabicConverter.arabicToRoman(arabic1999);
+
+        assertThat(result).isEqualTo("MCMXCIX");
+    }
+
+}
@@ -0,0 +1,66 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>antlr</artifactId>
+    <name>antlr</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.antlr</groupId>
+                <artifactId>antlr4-maven-plugin</artifactId>
+                <version>${antlr.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>antlr4</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <version>${mojo.version}</version>
+                <executions>
+                    <execution>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>add-source</goal>
+                        </goals>
+                        <configuration>
+                            <sources>
+                                <source>${basedir}/target/generated-sources/antlr4</source>
+                            </sources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+		<dependency>
+			<groupId>org.antlr</groupId>
+			<artifactId>antlr4-runtime</artifactId>
+			<version>${antlr.version}</version>
+		</dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <properties>
+        <java.version>1.8</java.version>
+        <antlr.version>4.7.1</antlr.version>
+        <junit.version>4.12</junit.version>
+        <mojo.version>3.0.0</mojo.version>
+    </properties>
+</project>
@@ -0,0 +1,16 @@
+grammar Log;
+
+log : entry+;
+entry : timestamp ' ' level ' ' message CRLF;
+timestamp : DATE ' ' TIME;
+level : 'ERROR' | 'INFO' | 'DEBUG';
+message : (TEXT | ' ')+;
+
+fragment DIGIT : [0-9];
+fragment TWODIGIT : DIGIT DIGIT;
+fragment LETTER : [A-Za-z];
+
+DATE : TWODIGIT TWODIGIT '-' LETTER LETTER LETTER '-' TWODIGIT;
+TIME : TWODIGIT ':' TWODIGIT ':' TWODIGIT;
+TEXT : LETTER+;
+CRLF : '\r'? '\n' | '\r';
@@ -0,0 +1,28 @@
+package com.baeldung.antlr.java;
+
+import com.baeldung.antlr.Java8BaseListener;
+import com.baeldung.antlr.Java8Parser;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class UppercaseMethodListener extends Java8BaseListener {
+
+    private List<String> errors = new ArrayList<String>();
+
+    @Override
+    public void enterMethodDeclarator(Java8Parser.MethodDeclaratorContext ctx) {
+        TerminalNode node = ctx.Identifier();
+        String methodName = node.getText();
+
+        if (Character.isUpperCase(methodName.charAt(0))){
+            errors.add(String.format("Method %s is uppercased!", methodName));
+        }
+    }
+
+    public List<String> getErrors(){
+        return Collections.unmodifiableList(errors);
+    }
+}
@@ -0,0 +1,51 @@
+package com.baeldung.antlr.log;
+
+import com.baeldung.antlr.LogBaseListener;
+import com.baeldung.antlr.LogParser;
+import com.baeldung.antlr.log.model.LogLevel;
+import com.baeldung.antlr.log.model.LogEntry;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public class LogListener extends LogBaseListener {
+
+    private static final DateTimeFormatter DEFAULT_DATETIME_FORMATTER
+            = DateTimeFormatter.ofPattern("yyyy-MMM-dd HH:mm:ss", Locale.ENGLISH);
+
+    private List<LogEntry> entries = new ArrayList<>();
+    private LogEntry currentLogEntry;
+
+    @Override
+    public void enterEntry(LogParser.EntryContext ctx) {
+        this.currentLogEntry = new LogEntry();
+    }
+
+    @Override
+    public void exitEntry(LogParser.EntryContext ctx) {
+        entries.add(currentLogEntry);
+    }
+
+    @Override
+    public void enterTimestamp(LogParser.TimestampContext ctx) {
+        currentLogEntry.setTimestamp(LocalDateTime.parse(ctx.getText(), DEFAULT_DATETIME_FORMATTER));
+    }
+
+    @Override
+    public void enterMessage(LogParser.MessageContext ctx) {
+        currentLogEntry.setMessage(ctx.getText());
+    }
+
+    @Override
+    public void enterLevel(LogParser.LevelContext ctx) {
+        currentLogEntry.setLevel(LogLevel.valueOf(ctx.getText()));
+    }
+
+    public List<LogEntry> getEntries() {
+        return Collections.unmodifiableList(entries);
+    }
+}
@@ -0,0 +1,35 @@
+package com.baeldung.antlr.log.model;
+
+
+import java.time.LocalDateTime;
+
+public class LogEntry {
+
+    private LogLevel level;
+    private String message;
+    private LocalDateTime timestamp;
+
+    public LogLevel getLevel() {
+        return level;
+    }
+
+    public void setLevel(LogLevel level) {
+        this.level = level;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public LocalDateTime getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(LocalDateTime timestamp) {
+        this.timestamp = timestamp;
+    }
+}
@@ -0,0 +1,5 @@
+package com.baeldung.antlr.log.model;
+
+public enum LogLevel {
+    DEBUG, INFO, ERROR
+}
@@ -0,0 +1,30 @@
+package com.baeldung.antlr;
+
+import com.baeldung.antlr.java.UppercaseMethodListener;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class JavaParserUnitTest {
+
+    @Test
+    public void whenOneMethodStartsWithUpperCase_thenOneErrorReturned() throws Exception{
+
+        String javaClassContent = "public class SampleClass { void DoSomething(){} }";
+        Java8Lexer java8Lexer = new Java8Lexer(CharStreams.fromString(javaClassContent));
+        CommonTokenStream tokens = new CommonTokenStream(java8Lexer);
+        Java8Parser java8Parser = new Java8Parser(tokens);
+        ParseTree tree = java8Parser.compilationUnit();
+        ParseTreeWalker walker = new ParseTreeWalker();
+        UppercaseMethodListener uppercaseMethodListener = new UppercaseMethodListener();
+        walker.walk(uppercaseMethodListener, tree);
+
+        assertThat(uppercaseMethodListener.getErrors().size(), is(1));
+        assertThat(uppercaseMethodListener.getErrors().get(0),
+                is("Method DoSomething is uppercased!"));
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.antlr;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.baeldung.antlr.log.LogListener;
+import com.baeldung.antlr.log.model.LogLevel;
+import com.baeldung.antlr.log.model.LogEntry;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.junit.Test;
+
+import java.time.LocalDateTime;
+
+
+public class LogParserUnitTest {
+
+    @Test
+    public void whenLogContainsOneErrorLogEntry_thenOneErrorIsReturned() throws Exception {
+        String logLines = "2018-May-05 14:20:21 DEBUG entering awesome method\r\n" +
+                "2018-May-05 14:20:24 ERROR Bad thing happened\r\n";
+        LogLexer serverLogLexer = new LogLexer(CharStreams.fromString(logLines));
+        CommonTokenStream tokens = new CommonTokenStream( serverLogLexer );
+        LogParser logParser = new LogParser(tokens);
+        ParseTreeWalker walker = new ParseTreeWalker();
+        LogListener logWalker = new LogListener();
+        walker.walk(logWalker, logParser.log());
+
+        assertThat(logWalker.getEntries().size(), is(2));
+        LogEntry error = logWalker.getEntries().get(1);
+        assertThat(error.getLevel(), is(LogLevel.ERROR));
+        assertThat(error.getMessage(), is("Bad thing happened"));
+        assertThat(error.getTimestamp(), is(LocalDateTime.of(2018,5,5,14,20,24)));
+    }
+}
@@ -3,8 +3,8 @@
 	xsi:schemaLocation="http://pmd.sf.net/ruleset/1.0.0 http://pmd.sf.net/ruleset_xml_schema.xsd" 
 	xsi:noNamespaceSchemaLocation="http://pmd.sf.net/ruleset_xml_schema.xsd">
 	<description>Baeldung custom PMD rules</description>
-	<rule name="UnitTestMustFollowNamingConventionRule" message="Test class name doesn't follow the naming convention" class="org.baeldung.pmd.UnitTestNamingConventionRule">
+	<rule name="UnitTestMustFollowNamingConventionRule" message="Unit test class names need to end in 'UnitTest', integration tests with 'IntegrationTest', etc " class="org.baeldung.pmd.UnitTestNamingConventionRule">
 		<description>Test does not follow Baeldung naming convention</description>
 		<priority>3</priority>
 	</rule>
-</ruleset>
+</ruleset>
@@ -3,6 +3,7 @@ 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;

@@ -43,4 +44,30 @@ class UseLocalDate {
        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;
+    }
+
 }
@@ -1,6 +1,8 @@
 package com.baeldung.datetime;

 import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.temporal.ChronoField;

 public class UseLocalDateTime {

@@ -8,4 +10,15 @@ public class UseLocalDateTime {
        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;
+    }
+
 }
@@ -1,12 +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;
+    }
 }
@@ -1,13 +1,15 @@
 package com.baeldung.datetime;

+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
 import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.Month;

 import org.junit.Test;

-import static org.junit.Assert.assertEquals;
-
 public class UseLocalDateTimeUnitTest {

    UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
@@ -19,4 +21,16 @@ public class UseLocalDateTimeUnitTest {
        assertEquals(LocalTime.of(6, 30), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30")
            .toLocalTime());
    }
+
+    @Test
+    public void givenLocalDateTime_whenSettingEndOfDay_thenReturnLastMomentOfDay() {
+        LocalDateTime givenTimed = LocalDateTime.parse("2018-06-23T05:55:55");
+
+        LocalDateTime endOfDayFromGivenDirectly = useLocalDateTime.getEndOfDayFromLocalDateTimeDirectly(givenTimed);
+        LocalDateTime endOfDayFromGiven = useLocalDateTime.getEndOfDayFromLocalDateTime(givenTimed);
+
+        assertThat(endOfDayFromGivenDirectly).isEqualTo(endOfDayFromGiven);
+        assertThat(endOfDayFromGivenDirectly.toLocalTime()).isEqualTo(LocalTime.MAX);
+        assertThat(endOfDayFromGivenDirectly.toString()).isEqualTo("2018-06-23T23:59:59.999999999");
+    }
 }
@@ -1,13 +1,15 @@
 package com.baeldung.datetime;

+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
 import java.time.DayOfWeek;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;

 import org.junit.Test;

-import static org.junit.Assert.assertEquals;
-
 public class UseLocalDateUnitTest {

    UseLocalDate useLocalDate = new UseLocalDate();
@@ -57,4 +59,33 @@ public class UseLocalDateUnitTest {
        assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"), useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
    }

+    @Test
+    public void givenLocalDate_whenSettingStartOfDay_thenReturnMidnightInAllCases() {
+        LocalDate given = LocalDate.parse("2018-06-23");
+
+        LocalDateTime startOfDayWithMethod = useLocalDate.getStartOfDay(given);
+        LocalDateTime startOfDayOfLocalDate = useLocalDate.getStartOfDayOfLocalDate(given);
+        LocalDateTime startOfDayWithMin = useLocalDate.getStartOfDayAtMinTime(given);
+        LocalDateTime startOfDayWithMidnight = useLocalDate.getStartOfDayAtMidnightTime(given);
+
+        assertThat(startOfDayWithMethod).isEqualTo(startOfDayWithMin)
+            .isEqualTo(startOfDayWithMidnight)
+            .isEqualTo(startOfDayOfLocalDate)
+            .isEqualTo(LocalDateTime.parse("2018-06-23T00:00:00"));
+        assertThat(startOfDayWithMin.toLocalTime()).isEqualTo(LocalTime.MIDNIGHT);
+        assertThat(startOfDayWithMin.toString()).isEqualTo("2018-06-23T00:00");
+    }
+
+    @Test
+    public void givenLocalDate_whenSettingEndOfDay_thenReturnLastMomentOfDay() {
+        LocalDate given = LocalDate.parse("2018-06-23");
+
+        LocalDateTime endOfDayWithMax = useLocalDate.getEndOfDay(given);
+        LocalDateTime endOfDayFromLocalTime = useLocalDate.getEndOfDayFromLocalTime(given);
+
+        assertThat(endOfDayWithMax).isEqualTo(endOfDayFromLocalTime);
+        assertThat(endOfDayWithMax.toLocalTime()).isEqualTo(LocalTime.MAX);
+        assertThat(endOfDayWithMax.toString()).isEqualTo("2018-06-23T23:59:59.999999999");
+    }
+
 }
@@ -1,6 +1,10 @@
 package com.baeldung.datetime;

+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;

@@ -17,4 +21,25 @@ public class UseZonedDateTimeUnitTest {
        ZonedDateTime zonedDatetime = zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
        Assert.assertEquals(zoneId, ZoneId.from(zonedDatetime));
    }
+
+    @Test
+    public void givenLocalDateOrZoned_whenSettingStartOfDay_thenReturnMidnightInAllCases() {
+        LocalDate given = LocalDate.parse("2018-06-23");
+        ZoneId zone = ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedGiven = ZonedDateTime.of(given, LocalTime.NOON, zone);
+
+        ZonedDateTime startOfOfDayWithMethod = zonedDateTime.getStartOfDay(given, zone);
+        ZonedDateTime startOfOfDayWithShorthandMethod = zonedDateTime.getStartOfDayShorthand(given, zone);
+        ZonedDateTime startOfOfDayFromZonedDateTime = zonedDateTime.getStartOfDayFromZonedDateTime(zonedGiven);
+        ZonedDateTime startOfOfDayAtMinTime = zonedDateTime.getStartOfDayAtMinTime(zonedGiven);
+        ZonedDateTime startOfOfDayAtMidnightTime = zonedDateTime.getStartOfDayAtMidnightTime(zonedGiven);
+
+        assertThat(startOfOfDayWithMethod).isEqualTo(startOfOfDayWithShorthandMethod)
+            .isEqualTo(startOfOfDayFromZonedDateTime)
+            .isEqualTo(startOfOfDayAtMinTime)
+            .isEqualTo(startOfOfDayAtMidnightTime);
+        assertThat(startOfOfDayWithMethod.toLocalTime()).isEqualTo(LocalTime.MIDNIGHT);
+        assertThat(startOfOfDayWithMethod.toLocalTime()
+            .toString()).isEqualTo("00:00");
+    }
 }
@@ -203,6 +203,11 @@
            <artifactId>mail</artifactId>
            <version>1.5.0-b01</version>
        </dependency>
+        <dependency>
+            <groupId>com.ibm.icu</groupId>
+            <artifactId>icu4j</artifactId>
+            <version>${icu4j.version}</version>
+        </dependency>
    </dependencies>

    <build>
@@ -473,6 +478,7 @@
        <maven-javadoc-plugin.version>3.0.0-M1</maven-javadoc-plugin.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
        <javax.mail.version>1.5.0-b01</javax.mail.version>
+        <icu4j.version>61.1</icu4j.version>
    </properties>

 </project>
@@ -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();
+    }
+
+}
@@ -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);
+    }
+}
@@ -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();
+    }
+}
@@ -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();
+    }
+}
@@ -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();
+    }
+}
@@ -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();
+    }
+}
@@ -0,0 +1,68 @@
+package com.baeldung.string;
+
+import com.ibm.icu.lang.UCharacter;
+import com.ibm.icu.text.BreakIterator;
+import org.apache.commons.lang.WordUtils;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class TitleCaseConverter {
+
+    private static final String WORD_SEPARATOR = " ";
+
+    public static String convertToTitleCaseIteratingChars(String text) {
+        if (text == null || text.isEmpty()) {
+            return text;
+        }
+
+        StringBuilder converted = new StringBuilder();
+
+        boolean convertNext = true;
+        for (char ch : text.toCharArray()) {
+            if (Character.isSpaceChar(ch)) {
+                convertNext = true;
+            } else if (convertNext) {
+                ch = Character.toTitleCase(ch);
+                convertNext = false;
+            } else {
+                ch = Character.toLowerCase(ch);
+            }
+            converted.append(ch);
+        }
+
+        return converted.toString();
+    }
+
+    public static String convertToTitleCaseSplitting(String text) {
+        if (text == null || text.isEmpty()) {
+            return text;
+        }
+
+        return Arrays
+          .stream(text.split(WORD_SEPARATOR))
+          .map(word -> word.isEmpty()
+            ? word
+            : Character.toTitleCase(word.charAt(0)) + word
+              .substring(1)
+              .toLowerCase())
+          .collect(Collectors.joining(WORD_SEPARATOR));
+    }
+
+    public static String convertToTitleCaseIcu4j(String text) {
+        if (text == null || text.isEmpty()) {
+            return text;
+        }
+
+        return UCharacter.toTitleCase(text, BreakIterator.getTitleInstance());
+    }
+
+    public static String convertToTileCaseWordUtilsFull(String text) {
+        return WordUtils.capitalizeFully(text);
+    }
+
+    public static String convertToTileCaseWordUtils(String text) {
+        return WordUtils.capitalize(text);
+    }
+
+}
@@ -0,0 +1,92 @@
+package com.baeldung.date;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.text.ParseException;
+import java.time.LocalDate;
+import java.time.OffsetDateTime;
+import java.util.Calendar;
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+public class DateWithoutTimeUnitTest {
+
+    private static final long MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+
+    @Test
+    public void whenGettingDateWithoutTimeUsingCalendar_thenReturnDateWithoutTime() {
+        Date dateWithoutTime = DateWithoutTime.getDateWithoutTimeUsingCalendar();
+
+        // first check the time is set to 0
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(dateWithoutTime);
+
+        assertEquals(0, calendar.get(Calendar.HOUR_OF_DAY));
+        assertEquals(0, calendar.get(Calendar.MINUTE));
+        assertEquals(0, calendar.get(Calendar.SECOND));
+        assertEquals(0, calendar.get(Calendar.MILLISECOND));
+
+        // we get the day of the date
+        int day = calendar.get(Calendar.DAY_OF_MONTH);
+
+        // if we add the mills of one day minus 1 we should get the same day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY - 1);
+        assertEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+
+        // if we add one full day in millis we should get a different day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY);
+        assertNotEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void whenGettingDateWithoutTimeUsingFormat_thenReturnDateWithoutTime() throws ParseException {
+        Date dateWithoutTime = DateWithoutTime.getDateWithoutTimeUsingFormat();
+
+        // first check the time is set to 0
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(dateWithoutTime);
+
+        assertEquals(0, calendar.get(Calendar.HOUR_OF_DAY));
+        assertEquals(0, calendar.get(Calendar.MINUTE));
+        assertEquals(0, calendar.get(Calendar.SECOND));
+        assertEquals(0, calendar.get(Calendar.MILLISECOND));
+
+        // we get the day of the date
+        int day = calendar.get(Calendar.DAY_OF_MONTH);
+
+        // if we add the mills of one day minus 1 we should get the same day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY - 1);
+        assertEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+
+        // if we add one full day in millis we should get a different day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY);
+        assertNotEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void whenGettingLocalDate_thenReturnDateWithoutTime() {
+        // get the local date
+        LocalDate localDate = DateWithoutTime.getLocalDate();
+
+        // get the millis of our LocalDate
+        long millisLocalDate = localDate
+          .atStartOfDay()
+          .toInstant(OffsetDateTime
+            .now()
+            .getOffset())
+          .toEpochMilli();
+
+        Calendar calendar = Calendar.getInstance();
+        // if we add the millis of one day minus 1 we should get the same day
+        calendar.setTimeInMillis(millisLocalDate + MILLISECONDS_PER_DAY - 1);
+        assertEquals(localDate.getDayOfMonth(), calendar.get(Calendar.DAY_OF_MONTH));
+
+        // if we add one full day in millis we should get a different day
+        calendar.setTimeInMillis(millisLocalDate + MILLISECONDS_PER_DAY);
+        assertNotEquals(localDate.getDayOfMonth(), calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+}
@@ -0,0 +1,45 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class DateExtractYearMonthDayIntegerValuesUnitTest {
+
+    DateExtractYearMonthDayIntegerValues extractYearMonthDateIntegerValues = new DateExtractYearMonthDayIntegerValues();
+    
+    Date date;
+    
+    @Before
+    public void setup() throws ParseException
+    {
+        date=new SimpleDateFormat("dd-MM-yyyy").parse("01-03-2018");
+    }
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=extractYearMonthDateIntegerValues.getYear(date);
+       assertThat(actualYear,is(2018));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=extractYearMonthDateIntegerValues.getMonth(date);
+       assertThat(actualMonth,is(02));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=extractYearMonthDateIntegerValues.getDay(date);
+       assertThat(actualDayOfMonth,is(01));
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.time.LocalDate;
+
+import org.junit.Test;
+
+public class LocalDateExtractYearMonthDayIntegerValuesUnitTest {
+
+    LocalDateExtractYearMonthDayIntegerValues localDateExtractYearMonthDayIntegerValues=new LocalDateExtractYearMonthDayIntegerValues();
+    
+    LocalDate localDate=LocalDate.parse("2007-12-03");
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=localDateExtractYearMonthDayIntegerValues.getYear(localDate);
+       assertThat(actualYear,is(2007));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=localDateExtractYearMonthDayIntegerValues.getMonth(localDate);
+       assertThat(actualMonth,is(12));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=localDateExtractYearMonthDayIntegerValues.getDay(localDate);
+       assertThat(actualDayOfMonth,is(03));
+    }
+}
--- a/Show More
+++ b/Show More