Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/breakcontinue/BreakContinue.java

@@ -0,0 +1,139 @@
+package com.baeldung.breakcontinue;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * @author Santosh
+ *
+ */
+
+public class BreakContinue {
+
+    public static int unlabeledBreak() {
+        String searchName = "Wilson";
+        int counter = 0;
+        List<String> names = Arrays.asList("John", "Peter", "Robert", "Wilson", "Anthony", "Donald", "Richard");
+
+        for (String name : names) {
+            counter++;
+            if (name.equalsIgnoreCase(searchName)) {
+                break;
+            }
+        }
+
+        return counter;
+    }
+
+    public static int unlabeledBreakNestedLoops() {
+        String searchName = "Wilson";
+        int counter = 0;
+        Map<String, List<String>> nameMap = new HashMap<>();
+        nameMap.put("Grade1", Arrays.asList("John", "Peter", "Robert", "Wilson"));
+        nameMap.put("Grade2", Arrays.asList("Anthony", "Donald", "Richard", "Arnold"));
+        nameMap.put("Grade3", Arrays.asList("Wilson", "Michael", "Stephen", "Ryan"));
+
+        Iterator<Entry<String, List<String>>> iterator = nameMap.entrySet()
+            .iterator();
+        Entry<String, List<String>> entry = null;
+        List<String> names = null;
+        while (iterator.hasNext()) {
+            entry = iterator.next();
+            names = entry.getValue();
+            for (String name : names) {
+                if (name.equalsIgnoreCase(searchName)) {
+                    counter++;
+                    break;
+                }
+            }
+        }
+
+        return counter;
+    }
+
+    public static int labeledBreak() {
+        String searchName = "Wilson";
+        int counter = 0;
+        Map<String, List<String>> nameMap = new HashMap<>();
+        nameMap.put("Grade1", Arrays.asList("John", "Peter", "Robert", "Wilson"));
+        nameMap.put("Grade2", Arrays.asList("Anthony", "Donald", "Richard", "Arnold"));
+        nameMap.put("Grade3", Arrays.asList("Wilson", "Michael", "Stephen", "Ryan"));
+
+        Iterator<Entry<String, List<String>>> iterator = nameMap.entrySet()
+            .iterator();
+        Entry<String, List<String>> entry = null;
+        List<String> names = null;
+        compare: 
+        while (iterator.hasNext()) {
+            entry = iterator.next();
+            names = entry.getValue();
+            for (String name : names) {
+                if (name.equalsIgnoreCase(searchName)) {
+                    counter++;
+                    break compare;
+                }
+            }
+        }
+
+        return counter;
+    }
+
+    public static int unlabeledContinue() {
+        String searchName = "Wilson";
+        int counter = 0;
+        Map<String, List<String>> nameMap = new HashMap<>();
+        nameMap.put("Grade1", Arrays.asList("John", "Wilson", "Robert", "Wilson"));
+        nameMap.put("Grade2", Arrays.asList("Anthony", "Donald", "Wilson", "Arnold"));
+        nameMap.put("Grade3", Arrays.asList("Wilson", "Michael", "Wilson", "Ryan"));
+
+        Iterator<Entry<String, List<String>>> iterator = nameMap.entrySet()
+            .iterator();
+        Entry<String, List<String>> entry = null;
+        List<String> names = null;
+        while (iterator.hasNext()) {
+            entry = iterator.next();
+            names = entry.getValue();
+            for (String name : names) {
+                if (!name.equalsIgnoreCase(searchName)) {
+                    continue;
+                }
+
+                counter++;
+            }
+        }
+
+        return counter;
+    }
+
+    public static int labeledContinue() {
+        String searchName = "Wilson";
+        int counter = 0;
+        Map<String, List<String>> nameMap = new HashMap<>();
+        nameMap.put("Grade1", Arrays.asList("John", "Wilson", "Robert", "Wilson"));
+        nameMap.put("Grade2", Arrays.asList("Anthony", "Donald", "Wilson", "Arnold"));
+        nameMap.put("Grade3", Arrays.asList("Wilson", "Michael", "Wilson", "Ryan"));
+
+        Iterator<Entry<String, List<String>>> iterator = nameMap.entrySet()
+            .iterator();
+        Entry<String, List<String>> entry = null;
+        List<String> names = null;
+        compare: 
+        while (iterator.hasNext()) {
+            entry = iterator.next();
+            names = entry.getValue();
+            for (String name : names) {
+                if (name.equalsIgnoreCase(searchName)) {
+                    counter++;
+                    continue compare;
+                }
+            }
+        }
+
+        return counter;
+    }
+
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/breakloop/LoopBreaking.java

@@ -0,0 +1,47 @@
+package com.baeldung.breakloop;
+
+public class LoopBreaking {
+
+    public String simpleBreak() {
+        String result = "";
+        for (int outerCounter = 0; outerCounter < 2; outerCounter++) {
+            result += "outer" + outerCounter;
+            for (int innerCounter = 0; innerCounter < 2; innerCounter++) {
+                result += "inner" + innerCounter;
+                if (innerCounter == 0) {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    public String labelBreak() {
+        String result = "";
+        myBreakLabel:
+        for (int outerCounter = 0; outerCounter < 2; outerCounter++) {
+            result += "outer" + outerCounter;
+            for (int innerCounter = 0; innerCounter < 2; innerCounter++) {
+                result += "inner" + innerCounter;
+                if (innerCounter == 0) {
+                    break myBreakLabel;
+                }
+            }
+        }
+        return result;
+    }
+
+    public String usingReturn() {
+        String result = "";
+        for (int outerCounter = 0; outerCounter < 2; outerCounter++) {
+            result += "outer" + outerCounter;
+            for (int innerCounter = 0; innerCounter < 2; innerCounter++) {
+                result += "inner" + innerCounter;
+                if (innerCounter == 0) {
+                    return result;
+                }
+            }
+        }
+        return "failed";
+    }
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/enums/Pizza.java

@@ -0,0 +1,88 @@
+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-modules/core-java-lang-syntax/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-modules/core-java-lang-syntax/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-modules/core-java-lang-syntax/src/main/java/com/baeldung/generics/Building.java

@@ -0,0 +1,12 @@
+package com.baeldung.generics;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Building {
+    private static final Logger LOGGER = LoggerFactory.getLogger(Building.class);
+
+    public void paint() {
+        LOGGER.info("Painting Building");
+    }
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/generics/Generics.java

@@ -0,0 +1,45 @@
+package com.baeldung.generics;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class Generics {
+
+    // definition of a generic method
+    public static <T> List<T> fromArrayToList(T[] a) {
+        return Arrays.stream(a).collect(Collectors.toList());
+    }
+
+    // definition of a generic method
+    public static <T, G> List<G> fromArrayToList(T[] a, Function<T, G> mapperFunction) {
+        return Arrays.stream(a).map(mapperFunction).collect(Collectors.toList());
+    }
+
+    // example of a generic method that has Number as an upper bound for T
+    public static <T extends Number> List<T> fromArrayToListWithUpperBound(T[] a) {
+        return Arrays.stream(a).collect(Collectors.toList());
+    }
+
+    // example of a generic method with a wild card, this method can be used
+    // with a list of any subtype of Building
+    public static void paintAllBuildings(List<? extends Building> buildings) {
+        buildings.forEach(Building::paint);
+    }
+
+    public static List<Integer> createList(int a) {
+        List<Integer> list = new ArrayList<>();
+        list.add(a);
+        return list;
+    }
+
+    public <T> List<T> genericMethod(List<T> list) {
+        return list.stream().collect(Collectors.toList());
+    }
+    
+    public List<Object> withErasure(List<Object> list) {
+        return list.stream().collect(Collectors.toList());
+    }
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/generics/House.java

@@ -0,0 +1,12 @@
+package com.baeldung.generics;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class House extends Building {
+    private static final Logger LOGGER = LoggerFactory.getLogger(House.class);
+
+    public void paint() {
+        LOGGER.info("Painting House");
+    }
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/initializationguide/User.java

@@ -0,0 +1,53 @@
+package com.baeldung.initializationguide;
+
+import java.io.Serializable;
+
+public class User implements Serializable, Cloneable {
+    private static final long serialVersionUID = 1L;
+    static String forum;
+    private String name;
+    private int id;
+
+    {
+        id = 0;
+        System.out.println("Instance Initializer");
+    }
+
+    static {
+    	forum = "Java";
+        System.out.println("Static Initializer");
+    }
+
+    public User(String name, int id) {
+        super();
+        this.name = name;
+        this.id = id;
+    }
+
+    public User() {
+        System.out.println("Constructor");
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    @Override
+    protected Object clone() throws CloneNotSupportedException {
+        return this;
+    }
+
+}
+

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/loops/InfiniteLoops.java

@@ -0,0 +1,23 @@
+package com.baeldung.loops;
+
+public class InfiniteLoops {
+
+    public void infiniteLoopUsingWhile() {
+        while (true) {
+            System.out.println("Infinite loop using while");
+        }
+    }
+
+    public void infiniteLoopUsingFor() {
+        for (;;) {
+            System.out.println("Infinite loop using for");
+        }
+    }
+
+    public void infiniteLoopUsingDoWhile() {
+        do {
+            System.out.println("Infinite loop using do-while");
+        } while (true);
+    }
+
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/loops/LoopsInJava.java

@@ -0,0 +1,43 @@
+package com.baeldung.loops;
+
+public class LoopsInJava {
+
+    public int[] simple_for_loop() {
+        int[] arr = new int[5];
+        for (int i = 0; i < 5; i++) {
+            arr[i] = i;
+            System.out.println("Simple for loop: i - " + i);
+        }
+        return arr;
+    }
+
+    public int[] enhanced_for_each_loop() {
+        int[] intArr = { 0, 1, 2, 3, 4 };
+        int[] arr = new int[5];
+        for (int num : intArr) {
+            arr[num] = num;
+            System.out.println("Enhanced for-each loop: i - " + num);
+        }
+        return arr;
+    }
+
+    public int[] while_loop() {
+        int i = 0;
+        int[] arr = new int[5];
+        while (i < 5) {
+            arr[i] = i;
+            System.out.println("While loop: i - " + i++);
+        }
+        return arr;
+    }
+
+    public int[] do_while_loop() {
+        int i = 0;
+        int[] arr = new int[5];
+        do {
+            arr[i] = i;
+            System.out.println("Do-While loop: i - " + i++);
+        } while (i < 5);
+        return arr;
+    }
+}

core-java-modules/core-java-lang-syntax/src/main/java/com/baeldung/switchstatement/SwitchStatement.java

@@ -0,0 +1,70 @@
+package com.baeldung.switchstatement;
+
+public class SwitchStatement {
+
+    public String exampleOfIF(String animal) {
+
+        String result;
+
+        if (animal.equals("DOG") || animal.equals("CAT")) {
+            result = "domestic animal";
+        } else if (animal.equals("TIGER")) {
+            result = "wild animal";
+        } else {
+            result = "unknown animal";
+        }
+        return result;
+    }
+
+    public String exampleOfSwitch(String animal) {
+
+        String result;
+
+        switch (animal) {
+        case "DOG":
+        case "CAT":
+            result = "domestic animal";
+            break;
+        case "TIGER":
+            result = "wild animal";
+            break;
+        default:
+            result = "unknown animal";
+            break;
+        }
+        return result;
+    }
+
+    public String forgetBreakInSwitch(String animal) {
+
+        String result;
+
+        switch (animal) {
+
+        case "DOG":
+            System.out.println("domestic animal");
+            result = "domestic animal";
+
+        default:
+            System.out.println("unknown animal");
+            result = "unknown animal";
+
+        }
+        return result;
+    }
+
+    public String constantCaseValue(String animal) {
+
+        String result = "";
+
+        final String dog = "DOG";
+
+        switch (animal) {
+
+        case dog:
+            result = "domestic animal";
+        }
+        return result;
+    }
+
+}