Merge remote-tracking branch 'origin/master'

Conflicts:
	jsf/pom.xml

.gitignore

@@ -7,8 +7,11 @@
 
 # Eclipse
 .settings/
+*.project
+*.classpath
 .prefs
 *.prefs
+.metadata/
 
 # Intellij
 .idea/
@@ -23,3 +26,4 @@ log/
 target/
 
 spring-openid/src/main/resources/application.properties
+.recommenders/

core-java-8/pom.xml

@@ -41,6 +41,12 @@
             <version>3.3.2</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>${org.slf4j.version}</version>
+        </dependency>
+
         <!-- test scoped -->
 
         <dependency>

core-java-8/src/main/java/com/baeldung/datetime/UseDuration.java

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

core-java-8/src/main/java/com/baeldung/datetime/UseLocalDate.java

@@ -0,0 +1,46 @@
+package com.baeldung.datetime;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAdjusters;
+
+public class UseLocalDate {
+    
+    public LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth){        
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+    
+    public LocalDate getLocalDateUsingParseMethod(String representation){        
+        return LocalDate.parse(representation);
+    }
+    
+    public LocalDate getLocalDateFromClock(){        
+        LocalDate localDate = LocalDate.now();
+        return localDate;
+    }
+    
+    public LocalDate getNextDay(LocalDate localDate){       
+        return localDate.plusDays(1);
+    }
+    
+    public LocalDate getPreviousDay(LocalDate localDate){        
+        return localDate.minus(1, ChronoUnit.DAYS);
+    }
+    
+    public DayOfWeek getDayOfWeek(LocalDate localDate){        
+        DayOfWeek day = localDate.getDayOfWeek();
+        return day;
+    }
+    
+    public LocalDate getFirstDayOfMonth(){        
+        LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
+        return firstDayOfMonth;
+    }
+    
+    public LocalDateTime getStartOfDay(LocalDate localDate){        
+        LocalDateTime startofDay = localDate.atStartOfDay();
+        return startofDay;
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/UseLocalDateTime.java

@@ -0,0 +1,11 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+
+public class UseLocalDateTime {
+    
+    public LocalDateTime getLocalDateTimeUsingParseMethod(String representation){        
+        return LocalDateTime.parse(representation);
+    }
+
+}

core-java-8/src/main/java/com/baeldung/datetime/UseLocalTime.java

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

core-java-8/src/main/java/com/baeldung/datetime/UsePeriod.java

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

core-java-8/src/main/java/com/baeldung/datetime/UseToInstant.java

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

core-java-8/src/main/java/com/baeldung/datetime/UseZonedDateTime.java

@@ -0,0 +1,13 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+public class UseZonedDateTime {
+    
+    public ZonedDateTime getZonedDateTime(LocalDateTime localDateTime,ZoneId zoneId){        
+        ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);
+        return zonedDateTime;
+    }
+}

core-java-8/src/main/java/com/baeldung/enums/Pizza.java

@@ -0,0 +1,91 @@
+package com.baeldung.enums;
+
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Pizza {
+
+    private static EnumSet<PizzaStatusEnum> deliveredPizzaStatuses =
+            EnumSet.of(PizzaStatusEnum.DELIVERED);
+
+    private PizzaStatusEnum status;
+
+    public enum PizzaStatusEnum {
+        ORDERED(5) {
+            @Override
+            public boolean isOrdered() {
+                return true;
+            }
+        },
+        READY(2) {
+            @Override
+            public boolean isReady() {
+                return true;
+            }
+        },
+        DELIVERED(0) {
+            @Override
+            public boolean isDelivered() {
+                return true;
+            }
+        };
+
+        private int timeToDelivery;
+
+        public boolean isOrdered() {
+            return false;
+        }
+
+        public boolean isReady() {
+            return false;
+        }
+
+        public boolean isDelivered() {
+            return false;
+        }
+
+        public int getTimeToDelivery() {
+            return timeToDelivery;
+        }
+
+        PizzaStatusEnum(int timeToDelivery) {
+            this.timeToDelivery = timeToDelivery;
+        }
+    }
+
+    public PizzaStatusEnum getStatus() {
+        return status;
+    }
+
+    public void setStatus(PizzaStatusEnum status) {
+        this.status = status;
+    }
+
+    public boolean isDeliverable() {
+        return this.status.isReady();
+    }
+
+    public void printTimeToDeliver() {
+        System.out.println("Time to delivery is " + this.getStatus().getTimeToDelivery() + " days");
+    }
+
+    public static List<Pizza> getAllUndeliveredPizzas(List<Pizza> input) {
+        return input.stream().filter((s) -> !deliveredPizzaStatuses.contains(s.getStatus())).collect(Collectors.toList());
+    }
+
+    public static EnumMap<PizzaStatusEnum, List<Pizza>> groupPizzaByStatus(List<Pizza> pzList) {
+        return pzList.stream().collect(
+                Collectors.groupingBy(Pizza::getStatus,
+                        () -> new EnumMap<>(PizzaStatusEnum.class), Collectors.toList()));
+    }
+
+    public void deliver() {
+        if (isDeliverable()) {
+            PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy().deliver(this);
+            this.setStatus(PizzaStatusEnum.DELIVERED);
+        }
+    }
+
+}

core-java-8/src/main/java/com/baeldung/enums/PizzaDeliveryStrategy.java

@@ -0,0 +1,18 @@
+package com.baeldung.enums;
+
+public enum PizzaDeliveryStrategy {
+    EXPRESS {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in express mode");
+        }
+    },
+    NORMAL {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in normal mode");
+        }
+    };
+
+    public abstract void deliver(Pizza pz);
+}

core-java-8/src/main/java/com/baeldung/enums/PizzaDeliverySystemConfiguration.java

@@ -0,0 +1,22 @@
+package com.baeldung.enums;
+
+
+public enum PizzaDeliverySystemConfiguration {
+    INSTANCE;
+
+    PizzaDeliverySystemConfiguration() {
+        // Do the configuration initialization which
+        // involves overriding defaults like delivery strategy
+    }
+
+    private PizzaDeliveryStrategy deliveryStrategy = PizzaDeliveryStrategy.NORMAL;
+
+    public static PizzaDeliverySystemConfiguration getInstance() {
+        return INSTANCE;
+    }
+
+    public PizzaDeliveryStrategy getDeliveryStrategy() {
+        return deliveryStrategy;
+    }
+
+}

core-java-8/src/main/java/com/baeldung/streamApi/Product.java

@@ -0,0 +1,51 @@
+package com.baeldung.streamApi;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+/**
+ * Created by Alex Vengr
+ */
+public class Product {
+
+    private int price;
+
+    private String name;
+
+    private boolean utilize;
+
+    public Product(int price, String name) {
+        this(price);
+        this.name = name;
+    }
+
+    public Product(int price) {
+        this.price = price;
+    }
+
+    public Product() {
+    }
+
+    public int getPrice() {
+        return price;
+    }
+
+    public void setPrice(int price) {
+        this.price = price;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+
+    public static Stream<String> streamOf(List<String> list) {
+        return (list == null || list.isEmpty()) ? Stream.empty() : list.stream();
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.datetime;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Month;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseLocalDateTest {
+    
+    UseLocalDate useLocalDate = new UseLocalDate();
+    
+    @Test
+    public void givenValues_whenUsingFactoryOf_thenLocalDate(){
+        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingFactoryOfMethod(2016,5,10).toString());
+    }
+    
+    @Test
+    public void givenString_whenUsingParse_thenLocalDate(){
+        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
+    }
+    
+    @Test
+    public void whenUsingClock_thenLocalDate(){
+        Assert.assertEquals(LocalDate.now(),useLocalDate.getLocalDateFromClock());
+    }
+    
+    @Test
+    public void givenDate_whenUsingPlus_thenNextDay(){
+        Assert.assertEquals(LocalDate.now().plusDays(1),useLocalDate.getNextDay(LocalDate.now()));
+    }
+    
+    @Test
+    public void givenDate_whenUsingMinus_thenPreviousDay(){
+        Assert.assertEquals(LocalDate.now().minusDays(1),useLocalDate.getPreviousDay(LocalDate.now()));
+    }
+    
+    @Test
+    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek(){
+        Assert.assertEquals(DayOfWeek.SUNDAY,useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
+    }
+    
+    @Test
+    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth(){
+        Assert.assertEquals(1,useLocalDate.getFirstDayOfMonth().getDayOfMonth());
+    }
+    
+    @Test
+    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight(){
+        Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"),useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
+    }
+
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.Month;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseLocalDateTimeTest {
+    
+    UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
+    
+    @Test
+    public void givenString_whenUsingParse_thenLocalDateTime(){
+        Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
+        Assert.assertEquals(LocalTime.of(6,30),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import java.time.LocalTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseLocalTimeTest {
+    
+    UseLocalTime useLocalTime = new UseLocalTime();
+    
+    @Test
+    public void givenValues_whenUsingFactoryOf_thenLocalTime(){
+        Assert.assertEquals("07:07:07",useLocalTime.getLocalTimeUsingFactoryOfMethod(7,7,7).toString());
+    }
+    
+    @Test
+    public void givenString_whenUsingParse_thenLocalTime(){
+        Assert.assertEquals("06:30",useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
+    }
+    
+    @Test
+    public void givenTime_whenAddHour_thenLocalTime(){
+        Assert.assertEquals("07:30",useLocalTime.addAnHour(LocalTime.of(6,30)).toString());
+    }
+    
+    @Test
+    public void getHourFromLocalTime(){
+        Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1,1)));
+    }
+    
+    @Test
+    public void getLocalTimeWithMinuteSetToValue(){
+        Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10,10), 20));
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UsePeriodTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Period;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UsePeriodTest {
+    UsePeriod usingPeriod=new UsePeriod();
+    
+    @Test
+    public void givenPeriodAndLocalDate_thenCalculateModifiedDate(){
+        Period period = Period.ofDays(1);
+        LocalDate localDate = LocalDate.parse("2007-05-10");
+        Assert.assertEquals(localDate.plusDays(1),usingPeriod.modifyDates(localDate, period));
+    }
+    
+    @Test
+    public void givenDates_thenGetPeriod(){
+        LocalDate localDate1 = LocalDate.parse("2007-05-10");
+        LocalDate localDate2 = LocalDate.parse("2007-05-15");
+        
+        Assert.assertEquals(Period.ofDays(5), usingPeriod.getDifferenceBetweenDates(localDate1, localDate2));
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseZonedDateTimeTest {
+    
+    UseZonedDateTime zonedDateTime=new UseZonedDateTime();
+    
+    @Test
+    public void givenZoneId_thenZonedDateTime(){
+        ZoneId zoneId=ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedDatetime=zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
+        Assert.assertEquals(zoneId,ZoneId.from(zonedDatetime));
+    }
+}

core-java-8/src/test/java/com/baeldung/enums/PizzaTest.java

@@ -0,0 +1,80 @@
+package com.baeldung.enums;
+
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+
+import static junit.framework.TestCase.assertTrue;
+
+public class PizzaTest {
+
+    @Test
+    public void givenPizaOrder_whenReady_thenDeliverable() {
+        Pizza testPz = new Pizza();
+        testPz.setStatus(Pizza.PizzaStatusEnum.READY);
+        assertTrue(testPz.isDeliverable());
+    }
+
+    @Test
+    public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
+        List<Pizza> pzList = new ArrayList<>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizzas(pzList);
+        assertTrue(undeliveredPzs.size() == 3);
+    }
+
+    @Test
+    public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() {
+
+        List<Pizza> pzList = new ArrayList<>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        EnumMap<Pizza.PizzaStatusEnum, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.DELIVERED).size() == 1);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.ORDERED).size() == 2);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.READY).size() == 1);
+    }
+
+    @Test
+    public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
+        Pizza pz = new Pizza();
+        pz.setStatus(Pizza.PizzaStatusEnum.READY);
+        pz.deliver();
+        assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED);
+    }
+
+}

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

@@ -0,0 +1,263 @@
+package com.baeldung.java8;
+
+import com.baeldung.streamApi.Product;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.stream.*;
+
+import static org.junit.Assert.*;
+
+public class Java8StreamApiTest {
+
+    private long counter;
+
+    private static Logger log = LoggerFactory.getLogger(Java8StreamApiTest.class);
+
+    private List<Product> productList;
+
+    @Before
+    public void init() {
+        productList = Arrays.asList(
+                new Product(23, "potatoes"), new Product(14, "orange"),
+                new Product(13, "lemon"), new Product(23, "bread"),
+                new Product(13, "sugar"));
+    }
+
+    @Test
+    public void checkPipeline_whenStreamOneElementShorter_thenCorrect() {
+
+        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
+        long size = list.stream().skip(1)
+                .map(element -> element.substring(0, 3)).count();
+        assertEquals(list.size() - 1, size);
+    }
+
+    @Test
+    public void checkOrder_whenChangeQuantityOfMethodCalls_thenCorrect() {
+
+        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
+
+        counter = 0;
+        long sizeFirst = list.stream()
+                .skip(2).map(element -> {
+                    wasCalled();
+                    return element.substring(0, 3);
+                }).count();
+        assertEquals(1, counter);
+
+        counter = 0;
+        long sizeSecond = list.stream().map(element -> {
+            wasCalled();
+            return element.substring(0, 3);
+        }).skip(2).count();
+        assertEquals(3, counter);
+    }
+
+    @Test
+    public void createEmptyStream_whenEmpty_thenCorrect() {
+
+        Stream<String> streamEmpty = Stream.empty();
+        assertEquals(0, streamEmpty.count());
+
+        List<String> names = Collections.emptyList();
+        Stream<String> streamOf = Product.streamOf(names);
+        assertTrue(streamOf.count() == 0);
+    }
+
+    @Test
+    public void createStream_whenCreated_thenCorrect() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> streamOfCollection = collection.stream();
+        assertEquals(3, streamOfCollection.count());
+
+        Stream<String> streamOfArray = Stream.of("a", "b", "c");
+        assertEquals(3, streamOfArray.count());
+
+        String[] arr = new String[]{"a", "b", "c"};
+        Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
+        assertEquals(2, streamOfArrayPart.count());
+
+        IntStream intStream = IntStream.range(1, 3);
+        LongStream longStream = LongStream.rangeClosed(1, 3);
+        Random random = new Random();
+        DoubleStream doubleStream = random.doubles(3);
+        assertEquals(2, intStream.count());
+        assertEquals(3, longStream.count());
+        assertEquals(3, doubleStream.count());
+
+        IntStream streamOfChars = "abc".chars();
+        IntStream str = "".chars();
+        assertEquals(3, streamOfChars.count());
+
+        Stream<String> streamOfString = Pattern.compile(", ").splitAsStream("a, b, c");
+        assertEquals("a", streamOfString.findFirst().get());
+
+        Path path = getPath();
+        Stream<String> streamOfStrings = null;
+        try {
+            streamOfStrings = Files.lines(path, Charset.forName("UTF-8"));
+        } catch (IOException e) {
+            log.error("Error creating streams from paths {}", path, e.getMessage(), e);
+        }
+        assertEquals("a", streamOfStrings.findFirst().get());
+
+        Stream<String> streamBuilder = Stream.<String>builder().add("a").add("b").add("c").build();
+        assertEquals(3, streamBuilder.count());
+
+        Stream<String> streamGenerated = Stream.generate(() -> "element").limit(10);
+        assertEquals(10, streamGenerated.count());
+
+        Stream<Integer> streamIterated = Stream.iterate(40, n -> n + 2).limit(20);
+        assertTrue(40 <= streamIterated.findAny().get());
+    }
+
+    @Test
+    public void runStreamPipeline_whenOrderIsRight_thenCorrect() {
+
+        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
+        Optional<String> stream = list.stream()
+                .filter(element -> {
+                    log.info("filter() was called");
+                    return element.contains("2");
+                }).map(element -> {
+                    log.info("map() was called");
+                    return element.toUpperCase();
+                }).findFirst();
+    }
+
+    @Test
+    public void reduce_whenExpected_thenCorrect() {
+
+        OptionalInt reduced = IntStream.range(1, 4).reduce((a, b) -> a + b);
+        assertEquals(6, reduced.getAsInt());
+
+        int reducedTwoParams = IntStream.range(1, 4).reduce(10, (a, b) -> a + b);
+        assertEquals(16, reducedTwoParams);
+
+        int reducedThreeParams = Stream.of(1, 2, 3)
+                .reduce(10, (a, b) -> a + b, (a, b) -> {
+                    log.info("combiner was called");
+                    return a + b;
+                });
+        assertEquals(16, reducedThreeParams);
+
+        int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream()
+                .reduce(10, (a, b) -> a + b, (a, b) -> {
+                    log.info("combiner was called");
+                    return a + b;
+                });
+        assertEquals(36, reducedThreeParamsParallel);
+    }
+
+    @Test
+    public void collecting_whenAsExpected_thenCorrect() {
+
+        List<String> collectorCollection = productList.stream()
+                .map(Product::getName).collect(Collectors.toList());
+
+        assertTrue(collectorCollection instanceof List);
+        assertEquals(5, collectorCollection.size());
+
+        String listToString = productList.stream().map(Product::getName)
+                .collect(Collectors.joining(", ", "[", "]"));
+
+        assertTrue(listToString.contains(",") && listToString.contains("[") && listToString.contains("]"));
+
+        double averagePrice = productList.stream().collect(Collectors.averagingInt(Product::getPrice));
+        assertTrue(17.2 == averagePrice);
+
+        int summingPrice = productList.stream().collect(Collectors.summingInt(Product::getPrice));
+        assertEquals(86, summingPrice);
+
+        IntSummaryStatistics statistics = productList.stream()
+                .collect(Collectors.summarizingInt(Product::getPrice));
+        assertEquals(23, statistics.getMax());
+
+        Map<Integer, List<Product>> collectorMapOfLists = productList.stream()
+                .collect(Collectors.groupingBy(Product::getPrice));
+        assertEquals(3, collectorMapOfLists.keySet().size());
+
+        Map<Boolean, List<Product>> mapPartioned = productList.stream()
+                .collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
+        assertEquals(2, mapPartioned.keySet().size());
+
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void collect_whenThrows_thenCorrect() {
+        Set<Product> unmodifiableSet = productList.stream()
+                .collect(Collectors.collectingAndThen(Collectors.toSet(),
+                        Collections::unmodifiableSet));
+        unmodifiableSet.add(new Product(4, "tea"));
+    }
+
+    @Test
+    public void customCollector_whenResultContainsAllElementsFrSource_thenCorrect() {
+        Collector<Product, ?, LinkedList<Product>> toLinkedList =
+                Collector.of(LinkedList::new, LinkedList::add,
+                        (first, second) -> {
+                            first.addAll(second);
+                            return first;
+                        });
+
+        LinkedList<Product> linkedListOfPersons = productList.stream().collect(toLinkedList);
+        assertTrue(linkedListOfPersons.containsAll(productList));
+    }
+
+    @Test
+    public void parallelStream_whenWorks_thenCorrect() {
+        Stream<Product> streamOfCollection = productList.parallelStream();
+        boolean isParallel = streamOfCollection.isParallel();
+        boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12)
+                .anyMatch(price -> price > 200);
+        assertTrue(isParallel && haveBigPrice);
+    }
+
+    @Test
+    public void parallel_whenIsParallel_thenCorrect() {
+        IntStream intStreamParallel =
+                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        boolean isParallel = intStreamParallel.isParallel();
+        assertTrue(isParallel);
+    }
+
+    @Test
+    public void parallel_whenIsSequential_thenCorrect() {
+        IntStream intStreamParallel =
+                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        IntStream intStreamSequential = intStreamParallel.sequential();
+        boolean isParallel = intStreamParallel.isParallel();
+        assertFalse(isParallel);
+    }
+
+    private Path getPath() {
+        Path path = null;
+        try {
+            path = Files.createTempFile(null, ".txt");
+        } catch (IOException e) {
+            log.error(e.getMessage());
+        }
+
+        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
+            writer.write("a\nb\nc");
+        } catch (IOException e) {
+            log.error(e.getMessage());
+        }
+        return path;
+    }
+
+    private void wasCalled() {
+        counter++;
+    }
+}

core-java/pom.xml

@@ -9,7 +9,11 @@
     <dependencies>
 
         <!-- utils -->
-
+        <dependency>
+            <groupId>net.sourceforge.collections</groupId>
+            <artifactId>collections-generic</artifactId>
+            <version>4.01</version>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
@@ -122,8 +126,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven-compiler-plugin.version}</version>
                 <configuration>
-                    <source>1.7</source>
-                    <target>1.7</target>
+                    <source>1.8</source>
+                    <target>1.8</target>
                 </configuration>
             </plugin>
 

core-java/src/main/java/com/baeldung/enums/Pizza.java

@@ -0,0 +1,110 @@
+package com.baeldung.enums;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.collections15.Predicate;
+
+import java.io.IOException;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Pizza {
+
+    private static EnumSet<PizzaStatus> undeliveredPizzaStatuses =
+            EnumSet.of(PizzaStatus.ORDERED, PizzaStatus.READY);
+
+    private PizzaStatus status;
+
+    @JsonFormat(shape = JsonFormat.Shape.OBJECT)
+    public enum PizzaStatus {
+        ORDERED(5) {
+            @Override
+            public boolean isOrdered() {
+                return true;
+            }
+        },
+        READY(2) {
+            @Override
+            public boolean isReady() {
+                return true;
+            }
+        },
+        DELIVERED(0) {
+            @Override
+            public boolean isDelivered() {
+                return true;
+            }
+        };
+
+        private int timeToDelivery;
+
+        public boolean isOrdered() {
+            return false;
+        }
+
+        public boolean isReady() {
+            return false;
+        }
+
+        public boolean isDelivered() {
+            return false;
+        }
+
+        @JsonProperty("timeToDelivery")
+        public int getTimeToDelivery() {
+            return timeToDelivery;
+        }
+
+        PizzaStatus(int timeToDelivery) {
+            this.timeToDelivery = timeToDelivery;
+        }
+    }
+
+    public PizzaStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PizzaStatus status) {
+        this.status = status;
+    }
+
+    public boolean isDeliverable() {
+        return this.status.isReady();
+    }
+
+    public void printTimeToDeliver() {
+        System.out.println("Time to delivery is " + this.getStatus().getTimeToDelivery() + " days");
+    }
+
+    public static List<Pizza> getAllUndeliveredPizzas(List<Pizza> input) {
+        return input.stream().filter(
+                (s) -> undeliveredPizzaStatuses.contains(s.getStatus()))
+                .collect(Collectors.toList());
+    }
+
+    public static EnumMap<PizzaStatus, List<Pizza>>
+    groupPizzaByStatus(List<Pizza> pzList) {
+        return pzList.stream().collect(
+                Collectors.groupingBy(Pizza::getStatus,
+                        () -> new EnumMap<>(PizzaStatus.class), Collectors.toList()));
+    }
+
+    public void deliver() {
+        if (isDeliverable()) {
+            PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy().deliver(this);
+            this.setStatus(PizzaStatus.DELIVERED);
+        }
+    }
+
+    public static String getJsonString(Pizza pz) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(pz);
+    }
+
+    private static Predicate<Pizza> thatAreNotDelivered() {
+        return entry -> undeliveredPizzaStatuses.contains(entry.getStatus());
+    }
+}

core-java/src/main/java/com/baeldung/enums/PizzaDeliveryStrategy.java

@@ -0,0 +1,18 @@
+package com.baeldung.enums;
+
+public enum PizzaDeliveryStrategy {
+    EXPRESS {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in express mode");
+        }
+    },
+    NORMAL {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in normal mode");
+        }
+    };
+
+    public abstract void deliver(Pizza pz);
+}

core-java/src/main/java/com/baeldung/enums/PizzaDeliverySystemConfiguration.java

@@ -0,0 +1,21 @@
+package com.baeldung.enums;
+
+public enum PizzaDeliverySystemConfiguration {
+    INSTANCE;
+
+    PizzaDeliverySystemConfiguration() {
+        // Do the configuration initialization which
+        // involves overriding defaults like delivery strategy
+    }
+
+    private PizzaDeliveryStrategy deliveryStrategy = PizzaDeliveryStrategy.NORMAL;
+
+    public static PizzaDeliverySystemConfiguration getInstance() {
+        return INSTANCE;
+    }
+
+    public PizzaDeliveryStrategy getDeliveryStrategy() {
+        return deliveryStrategy;
+    }
+
+}

core-java/src/test/java/org/baeldung/java/enums/PizzaTest.java

@@ -0,0 +1,80 @@
+package org.baeldung.java.enums;
+
+
+import com.baeldung.enums.Pizza;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+
+import static junit.framework.TestCase.assertTrue;
+
+
+public class PizzaTest {
+    @Test
+    public void givenPizaOrder_whenReady_thenDeliverable() {
+        Pizza testPz = new Pizza();
+        testPz.setStatus(Pizza.PizzaStatus.READY);
+        assertTrue(testPz.isDeliverable());
+    }
+
+    @Test
+    public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
+        List<Pizza> pzList = new ArrayList<>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatus.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatus.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatus.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizzas(pzList);
+        assertTrue(undeliveredPzs.size() == 3);
+    }
+
+    @Test
+    public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() {
+
+        List<Pizza> pzList = new ArrayList<>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatus.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatus.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatus.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        EnumMap<Pizza.PizzaStatus, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
+        assertTrue(map.get(Pizza.PizzaStatus.DELIVERED).size() == 1);
+        assertTrue(map.get(Pizza.PizzaStatus.ORDERED).size() == 2);
+        assertTrue(map.get(Pizza.PizzaStatus.READY).size() == 1);
+    }
+
+    @Test
+    public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
+        Pizza pz = new Pizza();
+        pz.setStatus(Pizza.PizzaStatus.READY);
+        pz.deliver();
+        assertTrue(pz.getStatus() == Pizza.PizzaStatus.DELIVERED);
+    }
+}

dependency-injection/.gitignore

@@ -0,0 +1,12 @@
+RemoteSystemsTempFiles/
+.classpath
+.project
+.settings/
+bin/
+.metadata/
+docs/*.autosave
+docs/*.autosave
+.recommenders/
+build/
+.gradle/
+.DS_Store

dependency-injection/build.gradle

@@ -0,0 +1,43 @@
+apply plugin: 'java'
+apply plugin: 'eclipse'
+
+allprojects {
+    apply plugin: 'java'
+    sourceCompatibility = 1.6
+    targetCompatibility = 1.6
+}
+
+repositories {
+        mavenCentral()
+}
+
+sourceSets {
+        main {
+                resources.srcDirs = ["src/main/java","src/main/resources"]
+        }
+        test {
+                resources.srcDirs = ["src/main/java", "src/main/resources", "src/test/resources"]
+        }
+}
+
+configurations {
+        compile
+}
+
+test {
+    testLogging {
+        events 'started', 'passed'
+    }
+}
+
+dependencies {
+        testCompile('junit:junit:4.11')
+        testCompile('org.mockito:mockito-all:1.10.19')
+		testCompile group: 'org.springframework', name: 'spring-test', version: '4.2.6.RELEASE'
+		testCompile group: 'org.springframework', name: 'spring-core', version: '4.2.6.RELEASE'
+		testCompile group: 'org.springframework', name: 'spring-beans', version: '4.2.6.RELEASE'
+		testCompile group: 'org.springframework', name: 'spring-context', version: '4.2.6.RELEASE'
+		testCompile group: 'javax.inject', name: 'javax.inject', version: '1'
+
+        testRuntime('junit:junit:4.11')
+}

dependency-injection/docs/autowired-type-demo-classdiagram.xml

@@ -0,0 +1 @@
+<mxfile userAgent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36" version="5.5.1.6" editor="www.draw.io" type="device"><diagram>7Vjvb+I4EP1rkO4+7KkhhW0/8qt3J3V1Velq7z5VbmKIb50M55hS9q/fGXtMEgLXrprthwqEEH6ZOJ5573nAvXiSP/1uxCr7BKnUvf5Z+tSLp71+/6If4ycBWw8MBpceWBqVeiiqgLn6Jhk8Y3StUlk2Ai2AtmrVBBMoCpnYBiaMgU0zbAG6+dSVWIYnVsA8EbqNflGpzUJawwr/Q6plFp4cDTm/B5F8XRpYF/y8Xj9euJe/nIswFydaZiKFTQ2KZ1hWA4Az07f8aSI1lTaUzd93deTqbt1GFry2Z24I67DbkLtMsRQ8BGMzWEIh9KxCxy4/STOc4SizucavEX7Fh5rt34y7wT80+G3ghumImKFZV7K4y1Th0SuFK/K3/Cut3bIaxNoCQtUKrgFW/By/Zlro0bQZKmFtEo7CsROSMEvJUR93JUclS8glLhlDjNTCqsfm7II1tdzF8a2YlqC7QsAKVGHL2sw3BGAAuyO6HPgZ2Rz9yC0jcIRf/IxhVFtaBTkeD3PKeT4KveYMrpTU6QgLulFGplOZQ4v1cqNyLQqit0boAgobtEBjodUSaZsmWGdpEHiUxir0zYgvWOJonGRKp9diC2uqc2nRFGE0zsCobzitCM/Ay8Yy6WiwesSc7mRtGFlizE2gmO700LUoCaCYBLQWq1I97BacI9mqGIO1kHNQyJR0NwENmAYWINg0iIsSk4GwI/JqC4dvCO5mgmNmZFNtJfGAQ7LaNnJ5cVxpNXX8L/m88dbI/0AbIAlgKtF3qSwSXNYIwZF5UNYIs61d2JcF1sCRVkmitAa+ylC4ApxkFrVaMhSkouWCZjgslHIlElUsr13M9LxCbrkqBG0yZeUccVrTBvsNbQs430K73SRTKa7dbUtWWOG5J6LZh5jHYIxvLPiEtqIB5jXBMVIYxvimcGMnUGB+guwaTyUKayNJXC/ThGO5rYngcu4dz4kgxL1GBOctEbSI1Wrf657Y0O6c+3+Y1Ry5cC2CabxzW/YHN32D6rhNNUH7FGrxIPUNlMoqoPmNj92j9g3YG7zQwh04mJtDgzxMYd/D958+z+/ux7P70ee7v778eTub3k/AGPw1pNnfj4BTngz9syQxZPrfwtA8RU0TL9m8Tz29w54+PG829egje73GfxQ00ejqjL2Gf/8Dcb+ru93Re31uDZrs5PZXuN157Efa90G2u3A7C+vUvjtj70D7PsheB+2bDwJa7duC9+gvv54c+yacH+jPP82xEa+uxvqt/G+N/7bdOcAzDLued7SOVCo6DKG+uNeyX0I1e5h47aALRhfNLrj7q1ur8sEid9AEo/bBRjjleSfVHfJJ0O43xiWPa9UNley8uu2Tg3dW3eiCBRSqG/Nfre6ri8PqDNcf4VXn5PHsOw==</diagram></mxfile>