Merge branch 'master' of https://github.com/JonCook/tutorials

guest/core-java/pom.xml

@@ -0,0 +1,35 @@
+<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.stackify</groupId>
+    <artifactId>core-java</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+	<name>core-java</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>${log4j2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <log4j2.version>2.8.2</log4j2.version>
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

guest/core-java/src/main/java/com/stackify/optional/Address.java

@@ -0,0 +1,40 @@
+package com.stackify.optional;
+
+public class Address {
+    private String addressLine;
+    private String city;
+    private Country country;
+
+    public Address(String addressLine, String city, Country country) {
+        super();
+        this.addressLine = addressLine;
+        this.city = city;
+        this.country = country;
+    }
+
+    public String getAddressLine() {
+        return addressLine;
+    }
+
+    public void setAddressLine(String addressLine) {
+        this.addressLine = addressLine;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public Country getCountry() {
+        return country;
+    }
+
+    public void setCountry(Country country) {
+        this.country = country;
+    }
+
+   
+}

guest/core-java/src/main/java/com/stackify/optional/Country.java

@@ -0,0 +1,29 @@
+package com.stackify.optional;
+
+public class Country {
+    private String name;
+    private String isocode;
+
+    public Country(String name, String isocode) {
+        super();
+        this.name = name;
+        this.isocode = isocode;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getIsocode() {
+        return isocode;
+    }
+
+    public void setIsocode(String isocode) {
+        this.isocode = isocode;
+    }
+
+}

guest/core-java/src/main/java/com/stackify/optional/User.java

@@ -0,0 +1,51 @@
+package com.stackify.optional;
+
+import java.util.Optional;
+
+public class User {
+    private String email;
+    private String password;
+
+    private Address address;
+
+    private String position;
+
+    public User(String email, String password) {
+        super();
+        this.email = email;
+        this.password = password;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public Optional<String> getPosition() {
+        return Optional.ofNullable(position);
+    }
+
+    public void setPosition(String position) {
+        this.position = position;
+    }
+
+}

guest/core-java/src/main/java/com/stackify/optional/chaining/Address.java

@@ -0,0 +1,38 @@
+package com.stackify.optional.chaining;
+
+import java.util.Optional;
+
+public class Address {
+    private String addressLine;
+    private String city;
+    private Country country;
+
+    public Address(String addressLine, String city) {
+        this.addressLine = addressLine;
+        this.city = city;
+    }
+
+    public String getAddressLine() {
+        return addressLine;
+    }
+
+    public void setAddressLine(String addressLine) {
+        this.addressLine = addressLine;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public Optional<Country> getCountry() {
+        return Optional.ofNullable(country);
+    }
+
+    public void setCountry(Country country) {
+        this.country = country;
+    }   
+}

guest/core-java/src/main/java/com/stackify/optional/chaining/Country.java

@@ -0,0 +1,28 @@
+package com.stackify.optional.chaining;
+
+public class Country {
+    private String name;
+    private String isocode;
+
+    public Country(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getIsocode() {
+        return isocode;
+    }
+
+    public void setIsocode(String isocode) {
+        this.isocode = isocode;
+    }
+
+   
+}

guest/core-java/src/main/java/com/stackify/optional/chaining/User.java

@@ -0,0 +1,50 @@
+package com.stackify.optional.chaining;
+
+import java.util.Optional;
+
+public class User {
+    private String email;
+    private String password;
+
+    private Address address;
+
+    private String position;
+
+    public User(String email, String password) {
+        this.email = email;
+        this.password = password;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Optional<Address> getAddress() {
+        return Optional.ofNullable(address);
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public Optional<String> getPosition() {
+        return Optional.ofNullable(position);
+    }
+
+    public void setPosition(String position) {
+        this.position = position;
+    }
+
+}

guest/core-java/src/main/java/com/stackify/optionalparams/MultiVitamin.java

@@ -0,0 +1,50 @@
+package com.stackify.optionalparams;
+
+public class MultiVitamin {
+
+    private String name;    // required
+    private int vitaminA;   // in mcg
+    private int vitaminC;   // in mg
+    private int calcium;    // in mg
+    private int iron;       // in mg
+
+    public MultiVitamin(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getVitaminA() {
+        return vitaminA;
+    }
+
+    public void setVitaminA(int vitaminA) {
+        this.vitaminA = vitaminA;
+    }
+
+    public int getVitaminC() {
+        return vitaminC;
+    }
+
+    public void setVitaminC(int vitaminC) {
+        this.vitaminC = vitaminC;
+    }
+
+    public int getCalcium() {
+        return calcium;
+    }
+
+    public void setCalcium(int calcium) {
+        this.calcium = calcium;
+    }
+
+    public int getIron() {
+        return iron;
+    }
+
+    public void setIron(int iron) {
+        this.iron = iron;
+    }
+}

guest/core-java/src/main/java/com/stackify/optionalparams/MultiVitaminAllowingNulls.java

@@ -0,0 +1,38 @@
+package com.stackify.optionalparams;
+
+public class MultiVitaminAllowingNulls {
+
+    private String name;    // required
+    private Integer vitaminA;   // in mcg
+    private Integer vitaminC;   // in mg
+    private Integer calcium;    // in mg
+    private Integer iron;       // in mg
+
+    public MultiVitaminAllowingNulls(String name, Integer vitaminA, Integer vitaminC, Integer calcium, Integer iron) {
+        this.name = name;
+        this.vitaminA = vitaminA;
+        this.vitaminC = vitaminC;
+        this.calcium = calcium;
+        this.iron = iron;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Integer getVitaminA() {
+        return vitaminA;
+    }
+
+    public Integer getVitaminC() {
+        return vitaminC;
+    }
+
+    public Integer getCalcium() {
+        return calcium;
+    }
+
+    public Integer getIron() {
+        return iron;
+    }
+}

guest/core-java/src/main/java/com/stackify/optionalparams/MultiVitaminOverloading.java

@@ -0,0 +1,56 @@
+package com.stackify.optionalparams;
+
+public class MultiVitaminOverloading {
+
+    static final int DEFAULT_IRON_AMOUNT = 20;
+
+    private final String name;    // required
+    private final int vitaminA;   // in mcg
+    private final int vitaminC;   // in mg
+    private final int calcium;    // in mg
+    private final int iron;       // in mg
+
+    public MultiVitaminOverloading(String name) {
+        this(name, 0);
+    }
+
+    public MultiVitaminOverloading(String name, int vitaminA) {
+        this(name, vitaminA, 0);
+    }
+
+    public MultiVitaminOverloading(String name, int vitaminA, int vitaminC) {
+        this(name, vitaminA, vitaminC, 0);
+    }
+
+    public MultiVitaminOverloading(String name, int vitaminA, int vitaminC, int calcium) {
+        this(name, vitaminA, vitaminC, calcium, DEFAULT_IRON_AMOUNT);
+    }
+
+    public MultiVitaminOverloading(String name, int vitaminA, int vitaminC, int calcium, int iron) {
+        this.name = name;
+        this.vitaminA = vitaminA;
+        this.vitaminC = vitaminC;
+        this.calcium = calcium;
+        this.iron = iron;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getVitaminA() {
+        return vitaminA;
+    }
+
+    public int getVitaminC() {
+        return vitaminC;
+    }
+
+    public int getCalcium() {
+        return calcium;
+    }
+
+    public int getIron() {
+        return iron;
+    }
+}

guest/core-java/src/main/java/com/stackify/optionalparams/MultiVitaminStaticFactoryMethods.java

@@ -0,0 +1,52 @@
+package com.stackify.optionalparams;
+
+public class MultiVitaminStaticFactoryMethods {
+
+    static final int IRON_AMT_DEF = 20;
+    static final int IRON_AMT_MEN = 30;
+
+    static final int CALCIUM_AMT_DEF = 100;
+    static final int CALCIUM_AMT_WOMEN = 120;
+
+    private final String name;    // required
+    private final int vitaminA;   // in mcg
+    private final int vitaminC;   // in mg
+    private final int calcium;    // in mg
+    private final int iron;       // in mg
+
+    public static MultiVitaminStaticFactoryMethods forMen(String name) {
+        return new MultiVitaminStaticFactoryMethods(name, 5000, 60, CALCIUM_AMT_DEF, IRON_AMT_MEN);
+    }
+
+    public static MultiVitaminStaticFactoryMethods forWomen(String name) {
+        return new MultiVitaminStaticFactoryMethods(name, 5000, 60, CALCIUM_AMT_WOMEN, IRON_AMT_DEF);
+    }
+
+    private MultiVitaminStaticFactoryMethods(String name, int vitaminA, int vitaminC, int calcium, int iron) {
+        this.name = name;
+        this.vitaminA = vitaminA;
+        this.vitaminC = vitaminC;
+        this.calcium = calcium;
+        this.iron = iron;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getVitaminA() {
+        return vitaminA;
+    }
+
+    public int getVitaminC() {
+        return vitaminC;
+    }
+
+    public int getCalcium() {
+        return calcium;
+    }
+
+    public int getIron() {
+        return iron;
+    }
+}

guest/core-java/src/main/java/com/stackify/optionalparams/MultiVitaminWithBuilder.java

@@ -0,0 +1,77 @@
+package com.stackify.optionalparams;
+
+public class MultiVitaminWithBuilder {
+
+    private final String name;    // required
+    private final int vitaminA;   // in mcg
+    private final int vitaminC;   // in mg
+    private final int calcium;    // in mg
+    private final int iron;       // in mg
+
+    private MultiVitaminWithBuilder(MultiVitaminBuilder builder) {
+        this.name = builder.name;
+        this.vitaminA = builder.vitaminA;
+        this.vitaminC = builder.vitaminC;
+        this.calcium = builder.calcium;
+        this.iron = builder.iron;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getVitaminA() {
+        return vitaminA;
+    }
+
+    public int getVitaminC() {
+        return vitaminC;
+    }
+
+    public int getCalcium() {
+        return calcium;
+    }
+
+    public int getIron() {
+        return iron;
+    }
+
+    public static class MultiVitaminBuilder {
+
+        private static final int ZERO = 0;
+
+        private final String name; // required
+        private int vitaminA = ZERO;
+        private int vitaminC = ZERO;
+        private int calcium = ZERO;
+        private int iron = ZERO;
+
+        public MultiVitaminBuilder(String name) {
+            this.name = name;
+        }
+
+        public MultiVitaminBuilder withVitaminA(int vitaminA) {
+            this.vitaminA = vitaminA;
+            return this;
+        }
+
+        public MultiVitaminBuilder withVitaminC(int vitaminC) {
+            this.vitaminC = vitaminC;
+            return this;
+        }
+
+        public MultiVitaminBuilder withCalcium(int calcium) {
+            this.calcium = calcium;
+            return this;
+        }
+
+        public MultiVitaminBuilder withIron(int iron) {
+            this.iron = iron;
+            return this;
+        }
+
+        public MultiVitaminWithBuilder build() {
+            return new MultiVitaminWithBuilder(this);
+        }
+    }
+}

guest/core-java/src/main/java/com/stackify/stream/Employee.java

@@ -0,0 +1,46 @@
+package com.stackify.stream;
+
+public class Employee {
+    private Integer id;
+    private String name;
+    private Double salary;
+    
+    public Employee(Integer id, String name, Double salary) {
+        this.id = id;
+        this.name = name;        
+        this.salary = salary;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public Double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(Double salary) {
+        this.salary = salary;
+    }
+    
+    public void salaryIncrement(Double percentage) {
+        Double newSalary = salary + percentage * salary / 100;
+        setSalary(newSalary);
+    }
+
+    public String toString() {
+        return "Id: " + id + " Name:" + name + " Price:" + salary;
+    }
+}

guest/core-java/src/main/java/com/stackify/stream/EmployeeRepository.java

@@ -0,0 +1,21 @@
+package com.stackify.stream;
+
+import java.util.List;
+
+public class EmployeeRepository {
+    private List<Employee> empList;
+    
+    public EmployeeRepository(List<Employee> empList) {
+        this.empList = empList;
+    
+    }
+    public Employee findById(Integer id) {
+        for (Employee emp : empList) {
+            if (emp.getId() == id) {
+                return emp;
+            }
+        }
+        
+        return null;
+    }
+}

guest/core-java/src/main/resources/log4j2.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+	<Appenders>
+		  <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%msg%n" />
+        </Console>
+	</Appenders>
+	<Loggers>
+		<Root level="info">
+			<AppenderRef ref="Console" />
+		</Root>
+	</Loggers>
+</Configuration>

guest/core-java/src/test/java/com/stackify/optional/OptionalTest.java

@@ -0,0 +1,166 @@
+package com.stackify.optional;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.junit.Test;
+
+public class OptionalTest {
+
+    private User user;
+
+    private Logger logger = LogManager.getLogger(OptionalTest.class);
+
+    @Test(expected = NullPointerException.class)
+    public void testNull() {
+        String isocode = user.getAddress().getCountry().getIsocode().toUpperCase();
+    }
+
+    @Test
+    public void test() {
+
+        if (user != null) {
+            Address address = user.getAddress();
+            if (address != null) {
+                Country country = address.getCountry();
+                if (country != null) {
+                    String isocode = country.getIsocode();
+                    if (isocode != null) {
+                        isocode = isocode.toUpperCase();
+                    }
+                }
+            }
+        }
+
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void whenCreateEmptyOptional_thenNull() {
+        Optional<User> emptyOpt = Optional.empty();
+        emptyOpt.get();
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void whenCreateOfEmptyOptional_thenNullPointerException() {
+        Optional<User> opt = Optional.of(user);
+    }
+
+    @Test
+    public void whenCreateOfNullableOptional_thenOk() {
+        String name = "John";
+        Optional<String> opt = Optional.ofNullable(name);
+        assertEquals("John", opt.get());
+    }
+
+    @Test
+    public void whenCheckIsPresent_thenOk() {
+        user = new User("john@gmail.com", "1234");
+        Optional<User> opt = Optional.ofNullable(user);
+        assertTrue(opt.isPresent());
+
+        assertEquals(user.getEmail(), opt.get().getEmail());
+    }
+
+    @Test
+    public void whenCheckIfPresent_thenOk() {
+        user = new User("john@gmail.com", "1234");
+        Optional<User> opt = Optional.ofNullable(user);
+        assertTrue(opt.isPresent());
+
+        opt.ifPresent(u -> assertEquals(user.getEmail(), u.getEmail()));
+    }
+
+    @Test
+    public void whenEmptyValue_thenReturnDefault() {
+        User user = null;
+        User user2 = new User("anna@gmail.com", "1234");
+        User result = Optional.ofNullable(user).orElse(user2);
+
+        assertEquals("anna@gmail.com", result.getEmail());
+    }
+
+    @Test
+    public void whenValueNotNull_thenIgnoreDefault() {
+        User user = new User("john@gmail.com", "1234");
+        User user2 = new User("anna@gmail.com", "1234");
+        User result = Optional.ofNullable(user).orElse(user2);
+
+        assertEquals("john@gmail.com", result.getEmail());
+    }
+
+    @Test
+    public void whenSetDefaultOrElseGet_thenOk() {
+        User user = null;
+        User user2 = new User("anna@gmail.com", "1234");
+        User result = Optional.ofNullable(user).orElseGet(() -> user2);
+
+        assertEquals("anna@gmail.com", result.getEmail());
+    }
+
+    @Test
+    public void givenPresentValue_whenCompare_thenOk() {
+        User user = new User("john@gmail.com", "1234");
+        logger.info("Using orElse");
+        User result = Optional.ofNullable(user).orElse(createNewUser());
+        logger.info("Using orElseGet");
+        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
+    }
+
+    private User createNewUser() {
+        logger.info("Creating New User");
+        return new User("extra@gmail.com", "1234");
+    }
+
+    @Test
+    public void givenEmptyValue_whenCompare_thenOk() {
+        User user = null;
+        logger.info("Using orElse");
+        User result = Optional.ofNullable(user).orElse(createNewUser());
+        logger.info("Using orElseGet");
+        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenThrowException_thenOk() {
+        User result = Optional.ofNullable(user).orElseThrow(() -> new IllegalArgumentException());
+    }
+
+    @Test
+    public void whenMap_thenOk() {
+        user = new User("anna@gmail.com", "1234");
+        String email = Optional.ofNullable(user).map(u -> u.getEmail()).orElse("default@gmail.com");
+        assertEquals(email, user.getEmail());
+
+    }
+
+    @Test
+    public void whenFlatMap_thenOk() {
+        user = new User("anna@gmail.com", "1234");
+        user.setPosition("Developer");
+        String position = Optional.ofNullable(user).flatMap(u -> u.getPosition()).orElse("default");
+        assertEquals(position, user.getPosition().get());
+
+    }
+
+    @Test
+    public void whenFilter_thenOk() {
+        user = new User("anna@gmail.com", "1234");
+        Optional<User> result = Optional.ofNullable(user).filter(u -> u.getEmail() != null && u.getEmail().contains("@"));
+
+        assertTrue(result.isPresent());
+    }
+
+    @Test
+    public void whenStream_thenOk() {
+        List<User> users = new ArrayList<>();
+        User user = users.stream().findFirst().orElse(new User("default", "1234"));
+        assertEquals(user.getEmail(), "default");
+    }
+
+}

guest/core-java/src/test/java/com/stackify/optional/chaining/OptionalChainingTest.java

@@ -0,0 +1,36 @@
+package com.stackify.optional.chaining;
+
+import static org.junit.Assert.*;
+
+import java.util.Optional;
+
+import org.junit.Test;
+
+public class OptionalChainingTest {
+
+    @Test
+    public void whenChaining_thenOk() {
+        User user = new User("anna@gmail.com", "1234");
+
+        String result = Optional.ofNullable(user)
+                .flatMap(u -> u.getAddress())
+                .flatMap(a -> a.getCountry())
+                .map(c -> c.getIsocode())
+                .orElse("default");
+
+        assertEquals(result, "default");
+    }
+    
+    @Test
+    public void whenChainingWithMethodReferences_thenOk() {
+        User user = new User("anna@gmail.com", "1234");
+
+        String result = Optional.ofNullable(user)
+                .flatMap(User::getAddress)
+                .flatMap(Address::getCountry)
+                .map(Country::getIsocode)
+                .orElse("default");
+
+        assertEquals(result, "default");
+    }
+}

guest/core-java/src/test/java/com/stackify/optionalparams/OptionalParamsUnitTest.java

@@ -0,0 +1,96 @@
+package com.stackify.optionalparams;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigDecimal;
+
+import org.assertj.core.util.Arrays;
+import org.junit.Test;
+
+public class OptionalParamsUnitTest {
+
+    @Test
+    public void whenCreateMultiVitaminWithOverloading_thenOk() {
+        MultiVitaminOverloading multiVitamin = new MultiVitaminOverloading("Default Multivitamin");
+
+        assertThat(multiVitamin.getName()).isEqualTo("Default Multivitamin");
+        assertThat(multiVitamin.getVitaminA()).isEqualTo(0);
+        assertThat(multiVitamin.getVitaminC()).isEqualTo(0);
+        assertThat(multiVitamin.getCalcium()).isEqualTo(0);
+        assertThat(multiVitamin.getIron()).isEqualTo(MultiVitaminOverloading.DEFAULT_IRON_AMOUNT);
+    }
+
+    @Test
+    public void whenCreateMultiVitaminWithStaticFactoryMethods_thenOk() {
+        MultiVitaminStaticFactoryMethods mensMultiVitamin = MultiVitaminStaticFactoryMethods.forMen("Complete for Men");
+
+        assertThat(mensMultiVitamin.getName()).isEqualTo("Complete for Men");
+        assertThat(mensMultiVitamin.getCalcium()).isEqualTo(MultiVitaminStaticFactoryMethods.CALCIUM_AMT_DEF);
+        assertThat(mensMultiVitamin.getIron()).isEqualTo(MultiVitaminStaticFactoryMethods.IRON_AMT_MEN);
+
+        MultiVitaminStaticFactoryMethods womensMultiVitamin = MultiVitaminStaticFactoryMethods.forWomen("Complete for Women");
+
+        assertThat(womensMultiVitamin.getName()).isEqualTo("Complete for Women");
+        assertThat(womensMultiVitamin.getCalcium()).isEqualTo(MultiVitaminStaticFactoryMethods.CALCIUM_AMT_WOMEN);
+        assertThat(womensMultiVitamin.getIron()).isEqualTo(MultiVitaminStaticFactoryMethods.IRON_AMT_DEF);
+    }
+
+    @Test
+    public void whenCreateMultiVitaminWithBuilder_thenOk() {
+        MultiVitaminWithBuilder vitamin = new MultiVitaminWithBuilder.MultiVitaminBuilder("Maximum Strength")
+          .withCalcium(100)
+          .withIron(200)
+          .withVitaminA(50)
+          .withVitaminC(1000)
+          .build();
+
+        assertThat(vitamin.getName()).isEqualTo("Maximum Strength");
+        assertThat(vitamin.getCalcium()).isEqualTo(100);
+        assertThat(vitamin.getIron()).isEqualTo(200);
+        assertThat(vitamin.getVitaminA()).isEqualTo(50);
+        assertThat(vitamin.getVitaminC()).isEqualTo(1000);
+    }
+
+    @Test
+    public void whenCreateMutliVitaminWithAccessors_thenOk() {
+        MultiVitamin vitamin = new MultiVitamin("Generic");
+        vitamin.setVitaminA(50);
+        vitamin.setVitaminC(1000);
+        vitamin.setCalcium(100);
+        vitamin.setIron(200);
+
+        assertThat(vitamin.getName()).isEqualTo("Generic");
+        assertThat(vitamin.getCalcium()).isEqualTo(100);
+        assertThat(vitamin.getIron()).isEqualTo(200);
+        assertThat(vitamin.getVitaminA()).isEqualTo(50);
+        assertThat(vitamin.getVitaminC()).isEqualTo(1000);
+    }
+
+    @Test
+    public void whenCreateMultiVitaminWithNulls_thenOk() {
+        MultiVitamin vitamin = new MultiVitamin(null);
+
+        assertThat(vitamin.getName()).isNull();
+    }
+
+    public void varArgsDemo() {
+        Object[] args = Arrays.array(Long.valueOf(1), Integer.valueOf(2), BigDecimal.valueOf(3));
+
+        processVarArgsWithCastingAntiPattern(args);
+    }
+
+    private void processVarArgsWithCastingAntiPattern(Object... args) {
+        String message = "processing %s as %s";
+
+        // never do this sort of thing
+        for (Object arg : args) {
+            if (arg instanceof Long) {
+                System.out.println(String.format(message, arg, "Long"));
+            } else if (arg instanceof Integer) {
+                System.out.println(String.format(message, arg, "Integer"));
+            } else if (arg instanceof BigDecimal) {
+                System.out.println(String.format(message, arg, "BigDecimal"));
+            }
+        }
+    }
+}

guest/core-java/src/test/java/com/stackify/stream/EmployeeTest.java

@@ -0,0 +1,455 @@
+package com.stackify.stream;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.beans.HasPropertyWithValue.hasProperty;
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.Set;
+import java.util.Vector;
+import java.util.function.BinaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.After;
+import org.junit.Test;
+
+public class EmployeeTest {
+    private String fileName = "src/test/resources/test.txt";
+    
+    private static Employee[] arrayOfEmps = {
+        new Employee(1, "Jeff Bezos", 100000.0), 
+        new Employee(2, "Bill Gates", 200000.0), 
+        new Employee(3, "Mark Zuckerberg", 300000.0)
+    };
+
+    private static List<Employee> empList = Arrays.asList(arrayOfEmps);
+    private static EmployeeRepository employeeRepository = new EmployeeRepository(empList);
+
+    @After
+    public void cleanup() throws IOException {
+        Files.deleteIfExists(Paths.get(fileName));
+    }
+    
+    @Test
+    public void whenGetStreamFromList_ObtainStream() {
+        assert(empList.stream() instanceof Stream<?>);
+    }
+
+    @Test
+    public void whenGetStreamFromArray_ObtainStream() {
+        assert(Stream.of(arrayOfEmps) instanceof Stream<?>);
+    }
+
+    @Test
+    public void whenGetStreamFromElements_ObtainStream() {
+        assert(Stream.of(arrayOfEmps[0], arrayOfEmps[1], arrayOfEmps[2]) instanceof Stream<?>);
+    }
+
+    @Test
+    public void whenBuildStreamFromElements_ObtainStream() {
+        Stream.Builder<Employee> empStreamBuilder = Stream.builder();
+        
+        empStreamBuilder.accept(arrayOfEmps[0]);
+        empStreamBuilder.accept(arrayOfEmps[1]);
+        empStreamBuilder.accept(arrayOfEmps[2]);
+
+        Stream<Employee> empStream = empStreamBuilder.build();
+        
+        assert(empStream instanceof Stream<?>);
+    }
+
+    @Test
+    public void whenIncrementSalaryForEachEmployee_thenApplyNewSalary() {
+        Employee[] arrayOfEmps = {
+            new Employee(1, "Jeff Bezos", 100000.0), 
+            new Employee(2, "Bill Gates", 200000.0), 
+            new Employee(3, "Mark Zuckerberg", 300000.0)
+        };
+
+        List<Employee> empList = Arrays.asList(arrayOfEmps);
+        
+        empList.stream().forEach(e -> e.salaryIncrement(10.0));
+        
+        assertThat(empList, contains(
+          hasProperty("salary", equalTo(110000.0)),
+          hasProperty("salary", equalTo(220000.0)),
+          hasProperty("salary", equalTo(330000.0))
+        ));
+    }
+
+    @Test
+    public void whenIncrementSalaryUsingPeek_thenApplyNewSalary() {
+        Employee[] arrayOfEmps = {
+            new Employee(1, "Jeff Bezos", 100000.0), 
+            new Employee(2, "Bill Gates", 200000.0), 
+            new Employee(3, "Mark Zuckerberg", 300000.0)
+        };
+
+        List<Employee> empList = Arrays.asList(arrayOfEmps);
+        
+        empList.stream()
+          .peek(e -> e.salaryIncrement(10.0))
+          .peek(System.out::println)
+          .collect(Collectors.toList());
+
+        assertThat(empList, contains(
+          hasProperty("salary", equalTo(110000.0)),
+          hasProperty("salary", equalTo(220000.0)),
+          hasProperty("salary", equalTo(330000.0))
+        ));
+    }
+
+    @Test
+    public void whenMapIdToEmployees_thenGetEmployeeStream() {
+        Integer[] empIds = { 1, 2, 3 };
+        
+        List<Employee> employees = Stream.of(empIds)
+          .map(employeeRepository::findById)
+          .collect(Collectors.toList());
+        
+        assertEquals(employees.size(), empIds.length);
+    }
+
+    @Test
+    public void whenFlatMapEmployeeNames_thenGetNameStream() {
+        List<List<String>> namesNested = Arrays.asList( 
+          Arrays.asList("Jeff", "Bezos"), 
+          Arrays.asList("Bill", "Gates"), 
+          Arrays.asList("Mark", "Zuckerberg"));
+
+        List<String> namesFlatStream = namesNested.stream()
+          .flatMap(Collection::stream)
+          .collect(Collectors.toList());
+
+        assertEquals(namesFlatStream.size(), namesNested.size() * 2);
+    }
+
+    @Test
+    public void whenFilterEmployees_thenGetFilteredStream() {
+        Integer[] empIds = { 1, 2, 3, 4 };
+        
+        List<Employee> employees = Stream.of(empIds)
+          .map(employeeRepository::findById)
+          .filter(e -> e != null)
+          .filter(e -> e.getSalary() > 200000)
+          .collect(Collectors.toList());
+        
+        assertEquals(Arrays.asList(arrayOfEmps[2]), employees);
+    }
+
+    @Test
+    public void whenFindFirst_thenGetFirstEmployeeInStream() {
+        Integer[] empIds = { 1, 2, 3, 4 };
+        
+        Employee employee = Stream.of(empIds)
+          .map(employeeRepository::findById)
+          .filter(e -> e != null)
+          .filter(e -> e.getSalary() > 100000)
+          .findFirst()
+          .orElse(null);
+        
+        assertEquals(employee.getSalary(), new Double(200000));
+    }
+
+    @Test
+    public void whenCollectStreamToList_thenGetList() {
+        List<Employee> employees = empList.stream().collect(Collectors.toList());
+        
+        assertEquals(empList, employees);
+    }
+
+    @Test
+    public void whenStreamToArray_thenGetArray() {
+        Employee[] employees = empList.stream().toArray(Employee[]::new);
+
+        assertThat(empList.toArray(), equalTo(employees));
+    }
+    
+    @Test
+    public void whenStreamCount_thenGetElementCount() {
+        Long empCount = empList.stream()
+          .filter(e -> e.getSalary() > 200000)
+          .count();
+
+        assertEquals(empCount, new Long(1));
+    }
+
+    @Test
+    public void whenLimitInfiniteStream_thenGetFiniteElements() {
+        Stream<Integer> infiniteStream = Stream.iterate(2, i -> i * 2);
+    
+        List<Integer> collect = infiniteStream
+          .skip(3)
+          .limit(5)
+          .collect(Collectors.toList());
+  
+        assertEquals(collect, Arrays.asList(16, 32, 64, 128, 256));
+    }
+    
+    @Test
+    public void whenSortStream_thenGetSortedStream() {
+        List<Employee> employees = empList.stream()
+          .sorted((e1, e2) -> e1.getName().compareTo(e2.getName()))
+          .collect(Collectors.toList());
+
+        assertEquals(employees.get(0).getName(), "Bill Gates");
+        assertEquals(employees.get(1).getName(), "Jeff Bezos");
+        assertEquals(employees.get(2).getName(), "Mark Zuckerberg");
+    }
+
+
+    @Test
+    public void whenFindMin_thenGetMinElementFromStream() {
+        Employee firstEmp = empList.stream()
+          .min((e1, e2) -> e1.getId() - e2.getId())
+          .orElseThrow(NoSuchElementException::new);
+
+        assertEquals(firstEmp.getId(), new Integer(1));
+    }
+    
+    @Test
+    public void whenFindMax_thenGetMaxElementFromStream() {
+        Employee maxSalEmp = empList.stream()
+          .max(Comparator.comparing(Employee::getSalary))
+          .orElseThrow(NoSuchElementException::new);
+
+        assertEquals(maxSalEmp.getSalary(), new Double(300000.0));
+    }
+    
+    @Test
+    public void whenApplyDistinct_thenRemoveDuplicatesFromStream() {
+        List<Integer> intList = Arrays.asList(2, 5, 3, 2, 4, 3);
+        List<Integer> distinctIntList = intList.stream().distinct().collect(Collectors.toList());
+        
+        assertEquals(distinctIntList, Arrays.asList(2, 5, 3, 4));
+    }
+
+    @Test
+    public void whenApplyMatch_thenReturnBoolean() {
+        List<Integer> intList = Arrays.asList(2, 4, 5, 6, 8);
+        
+        boolean allEven = intList.stream().allMatch(i -> i % 2 == 0);
+        boolean oneEven = intList.stream().anyMatch(i -> i % 2 == 0);
+        boolean noneMultipleOfThree = intList.stream().noneMatch(i -> i % 3 == 0);
+        
+        assertEquals(allEven, false);
+        assertEquals(oneEven, true);
+        assertEquals(noneMultipleOfThree, false);
+    }
+    
+    @Test
+    public void whenFindMaxOnIntStream_thenGetMaxInteger() {
+        Integer latestEmpId = empList.stream()
+          .mapToInt(Employee::getId)
+          .max()
+          .orElseThrow(NoSuchElementException::new);
+
+        assertEquals(latestEmpId, new Integer(3));
+    }
+
+    @Test
+    public void whenApplySumOnIntStream_thenGetSum() {
+        Double avgSal = empList.stream()
+          .mapToDouble(Employee::getSalary)
+          .average()
+          .orElseThrow(NoSuchElementException::new);
+        
+        assertEquals(avgSal, new Double(200000));
+    }
+    
+    @Test
+    public void whenApplyReduceOnStream_thenGetValue() {
+        Double sumSal = empList.stream()
+          .map(Employee::getSalary)
+          .reduce(0.0, Double::sum);
+
+        assertEquals(sumSal, new Double(600000));
+    }
+    
+    @Test
+    public void whenCollectByJoining_thenGetJoinedString() {
+        String empNames = empList.stream()
+          .map(Employee::getName)
+          .collect(Collectors.joining(", "))
+          .toString();
+        
+        assertEquals(empNames, "Jeff Bezos, Bill Gates, Mark Zuckerberg");
+    }
+    
+    @Test
+    public void whenCollectBySet_thenGetSet() {
+        Set<String> empNames = empList.stream()
+                .map(Employee::getName)
+                .collect(Collectors.toSet());
+        
+        assertEquals(empNames.size(), 3);
+    }
+    
+    @Test
+    public void whenToVectorCollection_thenGetVector() {
+        Vector<String> empNames = empList.stream()
+                .map(Employee::getName)
+                .collect(Collectors.toCollection(Vector::new));
+        
+        assertEquals(empNames.size(), 3);
+    }
+
+    @Test
+    public void whenApplySummarizing_thenGetBasicStats() {
+        DoubleSummaryStatistics stats = empList.stream()
+          .collect(Collectors.summarizingDouble(Employee::getSalary));
+
+        assertEquals(stats.getCount(), 3);
+        assertEquals(stats.getSum(), 600000.0, 0);
+        assertEquals(stats.getMin(), 100000.0, 0);
+        assertEquals(stats.getMax(), 300000.0, 0);
+        assertEquals(stats.getAverage(), 200000.0, 0);
+    }
+
+    @Test
+    public void whenApplySummaryStatistics_thenGetBasicStats() {
+        DoubleSummaryStatistics stats = empList.stream()
+          .mapToDouble(Employee::getSalary)
+          .summaryStatistics();
+
+        assertEquals(stats.getCount(), 3);
+        assertEquals(stats.getSum(), 600000.0, 0);
+        assertEquals(stats.getMin(), 100000.0, 0);
+        assertEquals(stats.getMax(), 300000.0, 0);
+        assertEquals(stats.getAverage(), 200000.0, 0);
+    }
+
+    @Test
+    public void whenStreamPartition_thenGetMap() {
+        List<Integer> intList = Arrays.asList(2, 4, 5, 6, 8);
+        Map<Boolean, List<Integer>> isEven = intList.stream().collect(
+          Collectors.partitioningBy(i -> i % 2 == 0));
+        
+        assertEquals(isEven.get(true).size(), 4);
+        assertEquals(isEven.get(false).size(), 1);
+    }
+    
+    @Test
+    public void whenStreamGroupingBy_thenGetMap() {
+        Map<Character, List<Employee>> groupByAlphabet = empList.stream().collect(
+          Collectors.groupingBy(e -> new Character(e.getName().charAt(0))));
+
+        assertEquals(groupByAlphabet.get('B').get(0).getName(), "Bill Gates");
+        assertEquals(groupByAlphabet.get('J').get(0).getName(), "Jeff Bezos");
+        assertEquals(groupByAlphabet.get('M').get(0).getName(), "Mark Zuckerberg");
+    }
+    
+    @Test
+    public void whenStreamMapping_thenGetMap() {
+        Map<Character, List<Integer>> idGroupedByAlphabet = empList.stream().collect(
+          Collectors.groupingBy(e -> new Character(e.getName().charAt(0)),
+            Collectors.mapping(Employee::getId, Collectors.toList())));
+
+        assertEquals(idGroupedByAlphabet.get('B').get(0), new Integer(2));
+        assertEquals(idGroupedByAlphabet.get('J').get(0), new Integer(1));
+        assertEquals(idGroupedByAlphabet.get('M').get(0), new Integer(3));
+    }
+
+    @Test
+    public void whenStreamReducing_thenGetValue() {
+        Double percentage = 10.0;
+        Double salIncrOverhead = empList.stream().collect(Collectors.reducing(
+            0.0, e -> e.getSalary() * percentage / 100, (s1, s2) -> s1 + s2));
+
+        assertEquals(salIncrOverhead, 60000.0, 0);
+    }
+    
+    @Test
+    public void whenStreamGroupingAndReducing_thenGetMap() {
+        Comparator<Employee> byNameLength = Comparator.comparing(Employee::getName);
+        
+        Map<Character, Optional<Employee>> longestNameByAlphabet = empList.stream().collect(
+          Collectors.groupingBy(e -> new Character(e.getName().charAt(0)),
+            Collectors.reducing(BinaryOperator.maxBy(byNameLength))));
+
+        assertEquals(longestNameByAlphabet.get('B').get().getName(), "Bill Gates");
+        assertEquals(longestNameByAlphabet.get('J').get().getName(), "Jeff Bezos");
+        assertEquals(longestNameByAlphabet.get('M').get().getName(), "Mark Zuckerberg");
+    }
+
+    @Test
+    public void whenParallelStream_thenPerformOperationsInParallel() {
+        Employee[] arrayOfEmps = {
+          new Employee(1, "Jeff Bezos", 100000.0), 
+          new Employee(2, "Bill Gates", 200000.0), 
+          new Employee(3, "Mark Zuckerberg", 300000.0)
+        };
+
+        List<Employee> empList = Arrays.asList(arrayOfEmps);
+        
+        empList.stream().parallel().forEach(e -> e.salaryIncrement(10.0));
+        
+        assertThat(empList, contains(
+          hasProperty("salary", equalTo(110000.0)),
+          hasProperty("salary", equalTo(220000.0)),
+          hasProperty("salary", equalTo(330000.0))
+        ));
+    }
+
+    @Test
+    public void whenGenerateStream_thenGetInfiniteStream() {
+        Stream.generate(Math::random)
+          .limit(5)
+          .forEach(System.out::println);
+    }
+
+    @Test
+    public void whenIterateStream_thenGetInfiniteStream() {
+        Stream<Integer> evenNumStream = Stream.iterate(2, i -> i * 2);
+    
+        List<Integer> collect = evenNumStream
+          .limit(5)
+          .collect(Collectors.toList());
+  
+        assertEquals(collect, Arrays.asList(2, 4, 8, 16, 32));
+    }
+
+    @Test
+    public void whenStreamToFile_thenGetFile() throws IOException {
+        String[] words = {
+          "hello", 
+          "refer",
+          "world",
+          "level"
+        };
+        
+        try (PrintWriter pw = new PrintWriter(
+          Files.newBufferedWriter(Paths.get(fileName)))) {
+            Stream.of(words).forEach(pw::println);
+        }
+    }
+    
+    private List<String> getPalindrome(Stream<String> stream, int length) {
+        return stream.filter(s -> s.length() == length)
+          .filter(s -> s.compareToIgnoreCase(
+            new StringBuilder(s).reverse().toString()) == 0)
+          .collect(Collectors.toList());
+    }
+    
+    @Test
+    public void whenFileToStream_thenGetStream() throws IOException {
+        whenStreamToFile_thenGetFile();
+        
+        List<String> str = getPalindrome(Files.lines(Paths.get(fileName)), 5);        
+        assertThat(str, contains("refer", "level"));
+    }
+}