Merge pull request #2 from eugenp/master

merging

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/relativelyprime/RelativelyPrime.java

@@ -0,0 +1,45 @@
+package com.baeldung.algorithms.relativelyprime;
+
+import java.math.BigInteger;
+
+class RelativelyPrime {
+
+    static boolean iterativeRelativelyPrime(int a, int b) {
+        return iterativeGCD(a, b) == 1;
+    }
+
+    static boolean recursiveRelativelyPrime(int a, int b) {
+        return recursiveGCD(a, b) == 1;
+    }
+
+    static boolean bigIntegerRelativelyPrime(int a, int b) {
+        return BigInteger.valueOf(a).gcd(BigInteger.valueOf(b)).equals(BigInteger.ONE);
+    }
+
+    private static int iterativeGCD(int a, int b) {
+        int tmp;
+        while (b != 0) {
+            if (a < b) {
+                tmp = a;
+                a = b;
+                b = tmp;
+            }
+            tmp = b;
+            b = a % b;
+            a = tmp;
+        }
+        return a;
+    }
+
+    private static int recursiveGCD(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        if (a < b) {
+            return recursiveGCD(b, a);
+        }
+        return recursiveGCD(b, a % b);
+    }
+
+
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/relativelyprime/RelativelyPrimeUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.algorithms.relativelyprime;
+
+import org.junit.Test;
+
+import static com.baeldung.algorithms.relativelyprime.RelativelyPrime.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RelativelyPrimeUnitTest {
+
+    @Test
+    public void givenNonRelativelyPrimeNumbers_whenCheckingIteratively_shouldReturnFalse() {
+
+        boolean result = iterativeRelativelyPrime(45, 35);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenRelativelyPrimeNumbers_whenCheckingIteratively_shouldReturnTrue() {
+
+        boolean result = iterativeRelativelyPrime(500, 501);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenNonRelativelyPrimeNumbers_whenCheckingRecursively_shouldReturnFalse() {
+
+        boolean result = recursiveRelativelyPrime(45, 35);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenRelativelyPrimeNumbers_whenCheckingRecursively_shouldReturnTrue() {
+
+        boolean result = recursiveRelativelyPrime(500, 501);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenNonRelativelyPrimeNumbers_whenCheckingUsingBigIntegers_shouldReturnFalse() {
+
+        boolean result = bigIntegerRelativelyPrime(45, 35);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenRelativelyPrimeNumbers_whenCheckingBigIntegers_shouldReturnTrue() {
+
+        boolean result = bigIntegerRelativelyPrime(500, 501);
+        assertThat(result).isTrue();
+    }
+}

cloud-foundry-uaa/cf-uaa-config/uaa.yml

@@ -1,12 +1,7 @@
 issuer:
   uri: http://localhost:8080/uaa
 
-spring_profiles: postgresql,default  
-  
-database.driverClassName: org.postgresql.Driver
-database.url: jdbc:postgresql:uaadb2
-database.username: postgres
-database.password: postgres  
+spring_profiles: default,hsqldb
   
 encryption:
   active_key_label: CHANGE-THIS-KEY

cloud-foundry-uaa/cf-uaa-oauth2-client/src/main/resources/application.properties

@@ -1,23 +1,11 @@
-# SECURITY OAUTH2 CLIENT (OAuth2ClientProperties)
-#spring.security.oauth2.client.provider.*= # OAuth provider details.
-#spring.security.oauth2.client.registration.*= # OAuth client registrations.
-
 server.port=8081
-#server.servlet.context-path=/uaa-client-webapp
 
-uaa.url=http://localhost:8080/uaa
 resource.server.url=http://localhost:8082
 
-spring.security.oauth2.client.registration.uaa.client-name=UAA OAuth2 Client
-spring.security.oauth2.client.registration.uaa.client-id=client1
-spring.security.oauth2.client.registration.uaa.client-secret=client1
-spring.security.oauth2.client.registration.uaa.authorization-grant-type=authorization_code
+spring.security.oauth2.client.registration.uaa.client-name=Web App Client
+spring.security.oauth2.client.registration.uaa.client-id=webappclient
+spring.security.oauth2.client.registration.uaa.client-secret=webappclientsecret
 spring.security.oauth2.client.registration.uaa.scope=resource.read,resource.write,openid,profile
-spring.security.oauth2.client.registration.uaa.redirect-uri=http://localhost:8081/login/oauth2/code/uaa
-#spring.security.oauth2.client.registration.uaa.redirect-uri=http://localhost:8081/**
 
-spring.security.oauth2.client.provider.uaa.token-uri=${uaa.url}/oauth/token
-spring.security.oauth2.client.provider.uaa.authorization-uri=${uaa.url}/oauth/authorize
-spring.security.oauth2.client.provider.uaa.jwk-set-uri=${uaa.url}/token_keys
-spring.security.oauth2.client.provider.uaa.user-info-uri=${uaa.url}/userinfo
-spring.security.oauth2.client.provider.uaa.user-name-attribute=user_name
+spring.security.oauth2.client.provider.uaa.issuer-uri=http://localhost:8080/uaa/oauth/token
+

cloud-foundry-uaa/cf-uaa-oauth2-resource-server/src/main/resources/application.properties

@@ -1,16 +1,3 @@
 server.port=8082
 
-uaa.url=http://localhost:8080/uaa
-
-#approch1
-spring.security.oauth2.resourceserver.jwt.issuer-uri=${uaa.url}/oauth/token
-
-#approch2
-#spring.security.oauth2.resourceserver.jwt.jwk-set-uri=${uaa.url}/token_key
-
-# SECURITY OAUTH2 CLIENT (OAuth2ClientProperties)
-#security.oauth2.client.client-id=client1
-#security.oauth2.client.client-secret=client1
-
-#security.oauth2.resource.jwt.key-uri=${uaa.url}/token_key
-#security.oauth2.resource.token-info-uri=${uaa.url}/oauth/check_token
+spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8080/uaa/oauth/token

core-groovy/README.md

@@ -9,3 +9,5 @@
 - [A Quick Guide to Iterating a Map in Groovy](https://www.baeldung.com/groovy-map-iterating)
 - [An Introduction to Traits in Groovy](https://www.baeldung.com/groovy-traits)
 - [Lists in Groovy](https://www.baeldung.com/groovy-lists)
+- [Converting a String to a Date in Groovy](https://www.baeldung.com/groovy-string-to-date)
+- [Guide to I/O in Groovy](https://www.baeldung.com/groovy-io)

core-groovy/src/main/groovy/com/baeldung/Person.groovy

@@ -0,0 +1,37 @@
+package com.baeldung
+
+class Person {
+    private String firstname
+    private String lastname
+    private Integer age
+
+    Person(String firstname, String lastname, Integer age) {
+        this.firstname = firstname
+        this.lastname = lastname
+        this.age = age
+    }
+
+    String getFirstname() {
+        return firstname
+    }
+
+    void setFirstname(String firstname) {
+        this.firstname = firstname
+    }
+
+    String getLastname() {
+        return lastname
+    }
+
+    void setLastname(String lastname) {
+        this.lastname = lastname
+    }
+
+    Integer getAge() {
+        return age
+    }
+
+    void setAge(Integer age) {
+        this.age = age
+    }
+}

core-groovy/src/main/groovy/com/baeldung/closures/Closures.groovy

@@ -0,0 +1,87 @@
+package com.baeldung.closures
+
+class Closures {
+    
+    def printWelcome = {
+        println "Welcome to Closures!"
+    }
+    
+    def print = { name ->
+        println name
+    }
+    
+    def formatToLowerCase(name) {
+        return name.toLowerCase()
+    }
+    def formatToLowerCaseClosure = { name ->
+        return name.toLowerCase()
+    }
+    
+    def count=0
+    
+    def increaseCount = {
+        count++
+    }
+    
+    def greet = {
+        return "Hello! ${it}"
+    }
+   
+    def multiply = { x, y ->
+        return x*y
+    }
+    
+    def calculate = {int x, int y, String operation ->
+        
+        //log closure
+        def log = {
+            println "Performing $it"
+        }
+        
+        def result = 0    
+        switch(operation) {
+            case "ADD":
+                log("Addition")
+                result = x+y
+                break
+            case "SUB":
+                log("Subtraction")
+                result = x-y
+                break
+            case "MUL":
+                log("Multiplication")
+                result = x*y
+                break
+            case "DIV":
+                log("Division")
+                result = x/y
+                break
+        }
+        return result
+    }
+    
+    def addAll = { int... args ->
+        return args.sum()
+    }
+    
+    def volume(Closure areaCalculator, int... dimensions) {
+        if(dimensions.size() == 3) {
+            
+            //consider dimension[0] = length, dimension[1] = breadth, dimension[2] = height
+            //for cube and cuboid
+            return areaCalculator(dimensions[0], dimensions[1]) * dimensions[2]
+        } else if(dimensions.size() == 2) {
+            
+            //consider dimension[0] = radius, dimension[1] = height
+            //for cylinder and cone
+            return areaCalculator(dimensions[0]) * dimensions[1]
+        } else if(dimensions.size() == 1) {
+            
+            //consider dimension[0] = radius
+            //for sphere
+            return areaCalculator(dimensions[0]) * dimensions[0]
+        }
+        
+    }
+     
+}

core-groovy/src/main/groovy/com/baeldung/closures/Employee.groovy

@@ -0,0 +1,6 @@
+package com.baeldung.closures
+
+class Employee {
+    
+    String fullName
+}

core-groovy/src/test/groovy/com/baeldung/closures/ClosuresUnitTest.groovy

@@ -0,0 +1,80 @@
+package com.baeldung.closures
+
+import spock.lang.Specification
+
+class ClosuresUnitTest extends GroovyTestCase {
+
+    Closures closures = new Closures()
+    
+    void testDeclaration() {
+        
+        closures.print("Hello! Closure")
+        closures.formatToLowerCaseClosure("Hello! Closure")
+        
+        closures.print.call("Hello! Closure")
+        closures.formatToLowerCaseClosure.call("Hello! Closure")
+        
+    }
+    
+    void testClosureVsMethods() {   
+        assert closures.formatToLowerCase("TONY STARK") == closures.formatToLowerCaseClosure("Tony STark")
+    }
+    
+    void testParameters() {
+        //implicit parameter
+        assert closures.greet("Alex") == "Hello! Alex"
+        
+        //multiple parameters
+        assert closures.multiply(2, 4) == 8
+        
+        assert closures.calculate(12, 4, "ADD") == 16
+        assert closures.calculate(12, 4, "SUB") == 8
+        assert closures.calculate(43, 8, "DIV") == 5.375
+                
+        //varags
+        assert closures.addAll(12, 10, 14) == 36
+       
+    }
+    
+    void testClosureAsAnArgument() {
+        assert closures.volume({ l, b -> return l*b }, 12, 6, 10) == 720
+        
+        assert closures.volume({ radius -> return Math.PI*radius*radius/3 }, 5, 10) == Math.PI * 250/3
+    }
+    
+    void testGStringsLazyEvaluation() {
+        def name = "Samwell"
+        def welcomeMsg = "Welcome! $name"
+        
+        assert welcomeMsg == "Welcome! Samwell"
+        
+        // changing the name does not affect original interpolated value
+        name = "Tarly"
+        assert welcomeMsg != "Welcome! Tarly"
+        
+        def fullName = "Tarly Samson"
+        def greetStr = "Hello! ${-> fullName}"
+        
+        assert greetStr == "Hello! Tarly Samson"
+
+        // this time changing the variable affects the interpolated String's value
+        fullName = "Jon Smith"
+        assert greetStr == "Hello! Jon Smith"
+    }
+    
+    void testClosureInLists() {
+        def list = [10, 11, 12, 13, 14, true, false, "BUNTHER"]
+        list.each {
+            println it
+        }
+        
+        assert [13, 14] == list.findAll{ it instanceof Integer && it >= 13}
+    }
+    
+    void testClosureInMaps() {
+        def map = [1:10, 2:30, 4:5]
+        
+        assert [10, 60, 20] == map.collect{it.key * it.value}
+    }
+    
+}

core-groovy/src/test/groovy/com/baeldung/lists/ListTest.groovy

@@ -129,13 +129,13 @@ class ListTest{
         assertTrue(filterList.findAll{it > 3} == [4, 5, 6, 76])
 
         assertTrue(filterList.findAll{ it instanceof Number} == [2, 1, 3, 4, 5, 6, 76])
-        
+
         assertTrue(filterList.grep( Number )== [2, 1, 3, 4, 5, 6, 76])
-        
+
         assertTrue(filterList.grep{ it> 6 }== [76])
 
         def conditionList = [2, 1, 3, 4, 5, 6, 76]
-        
+
         assertFalse(conditionList.every{ it < 6})
 
         assertTrue(conditionList.any{ it%2 == 0})
@@ -165,7 +165,7 @@ class ListTest{
 
         def strList = ["na", "ppp", "as"]
         assertTrue(strList.max() == "ppp")
-        
+
         Comparator minc = {a,b -> a == b? 0: a < b? -1 : 1}
         def numberList = [3, 2, 0, 7]
         assertTrue(numberList.min(minc) == 0)

core-groovy/src/test/groovy/com/baeldung/lists/ListUnitTest.groovy

@@ -0,0 +1,58 @@
+package com.baeldung.lists
+
+import com.baeldung.Person
+import org.junit.Test
+
+import static org.junit.Assert.*
+
+class ListUnitTest {
+
+    private final personList = [
+      new Person("Regina", "Fitzpatrick", 25),
+      new Person("Abagail", "Ballard", 26),
+      new Person("Lucian", "Walter", 30),
+    ]
+
+    @Test
+    void whenListContainsElement_thenCheckReturnsTrue() {
+        def list = ['a', 'b', 'c']
+
+        assertTrue(list.indexOf('a') > -1)
+        assertTrue(list.contains('a'))
+    }
+
+    @Test
+    void whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue() {
+        def list = ['a', 'b', 'c']
+
+        assertTrue('a' in list)
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList() {
+        assertTrue(personList.stream().anyMatch {it.age > 20})
+        assertFalse(personList.stream().allMatch {it.age < 30})
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList() {
+        assertTrue(personList.any {it.age > 20})
+        assertFalse(personList.every {it.age < 30})
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements() {
+        assertTrue(personList.stream().filter {it.age > 20}.findAny().isPresent())
+        assertFalse(personList.stream().filter {it.age > 30}.findAny().isPresent())
+        assertTrue(personList.stream().filter {it.age > 20}.findAll().size() == 3)
+        assertTrue(personList.stream().filter {it.age > 30}.findAll().isEmpty())
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements() {
+        assertNotNull(personList.find {it.age > 20})
+        assertNull(personList.find {it.age > 30})
+        assertTrue(personList.findAll {it.age > 20}.size() == 3)
+        assertTrue(personList.findAll {it.age > 30}.isEmpty())
+    }
+}

core-groovy/src/test/groovy/com/baeldung/map/MapUnitTest.groovy

@@ -1,10 +1,18 @@
 package com.baeldung.map
 
-import static org.junit.Assert.*
+import com.baeldung.Person
 import org.junit.Test
 
+import static org.junit.Assert.*
+
 class MapUnitTest {
 
+    private final personMap = [
+      Regina : new Person("Regina", "Fitzpatrick", 25),
+      Abagail: new Person("Abagail", "Ballard", 26),
+      Lucian : new Person("Lucian", "Walter", 30)
+    ]
+
     @Test
     void whenUsingEach_thenMapIsIterated() {
         def map = [
@@ -63,7 +71,7 @@ class MapUnitTest {
             'FF6347' : 'Tomato',
             'FF4500' : 'Orange Red'
         ]
-        
+
         map.eachWithIndex { key, val, index ->
             def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
             println "$indent Hex Code: $key = Color Name: $val"
@@ -82,4 +90,65 @@ class MapUnitTest {
             println "Hex Code: $entry.key = Color Name: $entry.value"
         }
     }
+
+    @Test
+    void whenMapContainsKeyElement_thenCheckReturnsTrue() {
+        def map = [a: 'd', b: 'e', c: 'f']
+
+        assertTrue(map.containsKey('a'))
+        assertFalse(map.containsKey('e'))
+        assertTrue(map.containsValue('e'))
+    }
+
+    @Test
+    void whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue() {
+        def map = [a: 'd', b: 'e', c: 'f']
+
+        assertTrue('a' in map)
+        assertFalse('f' in map)
+    }
+
+    @Test
+    void whenMapContainsFalseBooleanValues_thenCheckReturnsFalse() {
+        def map = [a: true, b: false, c: null]
+
+        assertTrue(map.containsKey('b'))
+        assertTrue('a' in map)
+        assertFalse('b' in map)
+        assertFalse('c' in map)
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap() {
+        assertTrue(personMap.keySet().stream().anyMatch {it == "Regina"})
+        assertFalse(personMap.keySet().stream().allMatch {it == "Albert"})
+        assertFalse(personMap.values().stream().allMatch {it.age < 30})
+        assertTrue(personMap.entrySet().stream().anyMatch {it.key == "Abagail" && it.value.lastname == "Ballard"})
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap() {
+        assertTrue(personMap.keySet().any {it == "Regina"})
+        assertFalse(personMap.keySet().every {it == "Albert"})
+        assertFalse(personMap.values().every {it.age < 30})
+        assertTrue(personMap.any {firstname, person -> firstname == "Abagail" && person.lastname == "Ballard"})
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements() {
+        assertNotNull(personMap.find {it.key == "Abagail" && it.value.lastname == "Ballard"})
+        assertTrue(personMap.findAll {it.value.age > 20}.size() == 3)
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements() {
+        assertTrue(
+          personMap.entrySet().stream()
+            .filter {it.key == "Abagail" && it.value.lastname == "Ballard"}
+            .findAny().isPresent())
+        assertTrue(
+          personMap.entrySet().stream()
+            .filter {it.value.age > 20}
+            .findAll().size() == 3)
+    }
 }

core-groovy/src/test/groovy/com/baeldung/set/SetUnitTest.groovy

@@ -0,0 +1,16 @@
+package com.baeldung.set
+
+import org.junit.Test
+
+import static org.junit.Assert.assertTrue
+
+class SetUnitTest {
+
+    @Test
+    void whenSetContainsElement_thenCheckReturnsTrue() {
+        def set = ['a', 'b', 'c'] as Set
+
+        assertTrue(set.contains('a'))
+        assertTrue('a' in set)
+    }
+}

core-java-11/README.md

@@ -5,3 +5,4 @@
 - [Java 11 String API Additions](https://www.baeldung.com/java-11-string-api)
 - [Java 11 Nest Based Access Control](https://www.baeldung.com/java-nest-based-access-control)
 - [Exploring the New HTTP Client in Java 9 and 11](https://www.baeldung.com/java-9-http-client)
+- [An Introduction to Epsilon GC: A No-Op Experimental Garbage Collector](https://www.baeldung.com/jvm-epsilon-gc-garbage-collector)

core-java-12/pom.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-12</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-12</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>12</maven.compiler.source.version>
+        <maven.compiler.target.version>12</maven.compiler.target.version>
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

core-java-12/src/test/java/com/baeldung/collectors/CollectorsUnitTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.collectors;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import org.junit.Test;
+
+import static java.util.stream.Collectors.maxBy;
+import static java.util.stream.Collectors.minBy;
+import static java.util.stream.Collectors.teeing;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for collectors additions in Java 12.
+ */
+public class CollectorsUnitTest {
+
+    @Test
+    public void whenTeeing_ItShouldCombineTheResultsAsExpected() {
+        List<Integer> numbers = Arrays.asList(42, 4, 2, 24);
+        Range range = numbers.stream()
+            .collect(teeing(minBy(Integer::compareTo), maxBy(Integer::compareTo), (min, max) -> new Range(min.orElse(null), max.orElse(null))));
+
+        assertThat(range).isEqualTo(new Range(2, 42));
+    }
+
+    /**
+     * Represents a closed range of numbers between {@link #min} and
+     * {@link #max}, both inclusive.
+     */
+    private static class Range {
+
+        private final Integer min;
+
+        private final Integer max;
+
+        Range(Integer min, Integer max) {
+            this.min = min;
+            this.max = max;
+        }
+
+        Integer getMin() {
+            return min;
+        }
+
+        Integer getMax() {
+            return max;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Range range = (Range) o;
+            return Objects.equals(getMin(), range.getMin()) && Objects.equals(getMax(), range.getMax());
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(getMin(), getMax());
+        }
+
+        @Override
+        public String toString() {
+            return "Range{" + "min=" + min + ", max=" + max + '}';
+        }
+    }
+}

core-java-8/src/test/java/com/baeldung/java8/Java8SortUnitTest.java

@@ -124,11 +124,44 @@ public class Java8SortUnitTest {
 
     @Test
     public final void givenStreamCustomOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
-        
         final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
         final Comparator<Human> nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
         
         final List<Human> sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList());
         Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
     }
+
+    @Test
+    public final void givenStreamComparatorOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        final List<Human> sortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName)).collect(Collectors.toList());
+        Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenStreamNaturalOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<String> letters = Lists.newArrayList("B", "A", "C");
+
+        final List<String> reverseSortedLetters = letters.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedLetters.get(0), equalTo("C"));
+    }
+
+    @Test
+    public final void givenStreamCustomOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+        final Comparator<Human> reverseNameComparator = (h1, h2) -> h2.getName().compareTo(h1.getName());
+
+        final List<Human> reverseSortedHumans = humans.stream().sorted(reverseNameComparator).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void givenStreamComparatorOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        final List<Human> reverseSortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName, Comparator.reverseOrder())).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
 }

core-java-9/README.md

@@ -27,3 +27,4 @@
 - [Immutable Set in Java](https://www.baeldung.com/java-immutable-set)
 - [Multi-Release Jar Files](https://www.baeldung.com/java-multi-release-jar)
 - [Ahead of Time Compilation (AoT)](https://www.baeldung.com/ahead-of-time-compilation)
+

core-java-collections/README.md

@@ -33,3 +33,4 @@
 - [Differences Between HashMap and Hashtable](https://www.baeldung.com/hashmap-hashtable-differences)
 - [Java ArrayList vs Vector](https://www.baeldung.com/java-arraylist-vs-vector)
 - [Defining a Char Stack in Java](https://www.baeldung.com/java-char-stack)
+- [Time Comparison of Arrays.sort(Object[]) and Arrays.sort(int[])](https://www.baeldung.com/arrays-sortobject-vs-sortint)

core-java-concurrency-basic/README.md

@@ -16,3 +16,4 @@
 - [Life Cycle of a Thread in Java](http://www.baeldung.com/java-thread-lifecycle)
 - [Runnable vs. Callable in Java](http://www.baeldung.com/java-runnable-callable)
 - [What is Thread-Safety and How to Achieve it](https://www.baeldung.com/java-thread-safety)
+- [How to Start a Thread in Java](https://www.baeldung.com/java-start-thread)

core-java-networking/src/main/java/com/baeldung/socket/read/Client.java

@@ -1,35 +1,27 @@
 package com.baeldung.socket.read;
 
-import java.net.*; 
+import java.net.*;
+import java.nio.charset.StandardCharsets;
 import java.io.*; 
 
 public class Client {
-
-    //Initialize socket, input and output stream
-    private Socket socket = null;
-    private DataInputStream in = null;
-    private DataOutputStream out = null;
     
     public void runClient(String ip, int port) {
         try {
-            socket = new Socket(ip, port);
+            Socket socket = new Socket(ip, port);
             System.out.println("Connected to server ...");
-            in = new DataInputStream(System.in);
-            out = new DataOutputStream(socket.getOutputStream());
-        } catch(Exception e) {
-            e.printStackTrace();
-        }
-        char type = 's'; // s for string
-        int length = 29;
-        String data = "This is a string of length 29";
-        byte[] dataInBytes = data.getBytes();         
-        //Sending data in TLV format        
-        try {
+            DataInputStream in = new DataInputStream(System.in);
+            DataOutputStream out = new DataOutputStream(socket.getOutputStream());
+            
+            char type = 's'; // s for string
+            int length = 29;
+            String data = "This is a string of length 29";
+            byte[] dataInBytes = data.getBytes(StandardCharsets.UTF_8);         
+            //Sending data in TLV format        
             out.writeChar(type);
             out.writeInt(length);
             out.write(dataInBytes);
         } catch (IOException e) {
-            // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

core-java-networking/src/main/java/com/baeldung/socket/read/Server.java

@@ -1,48 +1,46 @@
 package com.baeldung.socket.read;
 
-import java.net.*; 
+import java.net.*;
+import java.nio.charset.StandardCharsets;
 import java.io.*; 
 
 public class Server {
-
-    //Socket and input stream
-    private Socket socket = null;
-    private ServerSocket server = null;
-    private DataInputStream in = null;
     
     public void runServer(int port) {
         //Start the server and wait for connection
         try {
-            server = new ServerSocket(port);
+            ServerSocket server = new ServerSocket(port);
             System.out.println("Server Started. Waiting for connection ...");
-            socket = server.accept();
+            Socket socket = server.accept();
             System.out.println("Got connection from client.");
             //Get input stream from socket variable and convert the same to DataInputStream
-            in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
+            DataInputStream in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
             //Read type and length of data
             char dataType = in.readChar();
             int length = in.readInt();
             System.out.println("Type : "+dataType);
             System.out.println("Lenght :"+length);
-            //Read String data in bytes
-            byte[] messageByte = new byte[length];
-            boolean end = false;
-            String dataString = "";
-            int totalBytesRead = 0;
-            //We need to run while loop, to read all data in that stream
-            while(!end) {
-                int currentBytesRead = in.read(messageByte);
-                totalBytesRead = currentBytesRead + totalBytesRead;
-                if(totalBytesRead <= length) {
-                    dataString += new String(messageByte,0,currentBytesRead);   
-                } else {
-                    dataString += new String(messageByte,0,length - totalBytesRead + currentBytesRead); 
-                }
-                if(dataString.length()>=length) {
-                    end = true;
+            if(dataType == 's') {
+                //Read String data in bytes
+                byte[] messageByte = new byte[length];
+                boolean end = false;
+                StringBuilder dataString = new StringBuilder(length);
+                int totalBytesRead = 0;
+                //We need to run while loop, to read all data in that stream
+                while(!end) {
+                    int currentBytesRead = in.read(messageByte);
+                    totalBytesRead = currentBytesRead + totalBytesRead;
+                    if(totalBytesRead <= length) {
+                        dataString.append(new String(messageByte,0,currentBytesRead,StandardCharsets.UTF_8));
+                    } else {
+                        dataString.append(new String(messageByte,0,length - totalBytesRead + currentBytesRead,StandardCharsets.UTF_8));
+                    }
+                    if(dataString.length()>=length) {
+                        end = true;
+                    }
                 }
+                System.out.println("Read "+length+" bytes of message from client. Message = "+dataString);
             }
-            System.out.println("Read "+length+" bytes of message from client. Message = "+dataString);;
         } catch (Exception e) {
             e.printStackTrace();
         }

core-java-os/README.md

@@ -6,3 +6,5 @@ This module uses Java 9, so make sure to have the JDK 9 installed to run it.
 ### Relevant Articles: 
 - [Java 9 Process API Improvements](http://www.baeldung.com/java-9-process-api)
 - [Guide to java.lang.Process API](https://www.baeldung.com/java-process-api)
+- [Guide to java.lang.ProcessBuilder API](https://www.baeldung.com/java-lang-processbuilder-api)
+

core-java/README.md

@@ -50,3 +50,4 @@
 - [Finding Leap Years in Java](https://www.baeldung.com/java-leap-year)
 - [Java Bitwise Operators](https://www.baeldung.com/java-bitwise-operators)
 - [Guide to Creating and Running a Jar File in Java](https://www.baeldung.com/java-create-jar)
+- [Making a JSON POST Request With HttpURLConnection](https://www.baeldung.com/httpurlconnection-post)

core-kotlin-2/README.md

@@ -3,4 +3,4 @@
 - [Void Type in Kotlin](https://www.baeldung.com/kotlin-void-type)
 - [How to use Kotlin Range Expressions](https://www.baeldung.com/kotlin-ranges)
 - [Split a List into Parts in Kotlin](https://www.baeldung.com/kotlin-split-list-into-parts)
-
+- [String Comparison in Kotlin](https://www.baeldung.com/kotlin-string-comparison)

core-kotlin-2/pom.xml

@@ -13,4 +13,66 @@
         <relativePath>../parent-kotlin</relativePath>
     </parent>
 
-</project>
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib-jdk8</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-test</artifactId>
+            <version>${kotlin.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-maven-plugin</artifactId>
+                <version>${kotlin.version}</version>
+                <executions>
+                    <execution>
+                        <id>compile</id>
+                        <phase>compile</phase>
+                        <goals>
+                            <goal>compile</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>test-compile</id>
+                        <phase>test-compile</phase>
+                        <goals>
+                            <goal>test-compile</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <jvmTarget>1.8</jvmTarget>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <kotlin.version>1.2.71</kotlin.version>
+        <junit.platform.version>1.1.1</junit.platform.version>
+        <junit.vintage.version>5.2.0</junit.vintage.version>
+        <assertj.version>3.10.0</assertj.version>
+    </properties>
+
+</project>

core-kotlin-2/src/main/kotlin/com/baeldung/range/CharRange.kt

@@ -0,0 +1,13 @@
+package com.baeldung.range
+
+fun main(args: Array<String>) {
+
+    for (ch in 'a'..'f') {
+        print(ch)
+    }
+    println()
+
+    for (ch in 'f' downTo 'a') {
+        print(ch)
+    }
+}

core-kotlin-2/src/main/kotlin/com/baeldung/range/Color.kt

@@ -0,0 +1,21 @@
+package com.baeldung.range
+
+enum class Color(val rgb: Int) {
+    BLUE(0x0000FF),
+    GREEN(0x008000),
+    RED(0xFF0000),
+    MAGENTA(0xFF00FF),
+    YELLOW(0xFFFF00);
+}
+
+fun main(args: Array<String>) {
+
+    println(Color.values().toList());
+    val red = Color.RED
+    val yellow = Color.YELLOW
+    val range = red..yellow
+
+    println(range.contains(Color.MAGENTA))
+    println(range.contains(Color.BLUE))
+    println(range.contains(Color.GREEN))
+}

core-kotlin-2/src/main/kotlin/com/baeldung/range/Filter.kt

@@ -0,0 +1,18 @@
+package com.baeldung.range
+
+fun main(args: Array<String>) {
+    val r = 1..10
+
+    //Apply filter
+    val f = r.filter { it -> it % 2 == 0 }
+    println(f)
+
+    //Map
+    val m = r.map { it -> it * it }
+    println(m)
+
+    //Reduce
+    val rdc = r.reduce { a, b -> a + b }
+    println(rdc)
+
+}