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-collections/src/main/java/com/baeldung/charstack/CharStack.java

@@ -0,0 +1,37 @@
+package com.baeldung.charstack;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class CharStack {
+
+    private LinkedList<Character> items;
+
+    public CharStack() {
+        this.items = new LinkedList<Character>();
+    }
+
+    public void push(Character item) {
+        items.push(item);
+    }
+
+    public Character peek() {
+        return items.getFirst();
+    }
+
+    public Character pop() {
+
+        Iterator<Character> iter = items.iterator();
+        Character item = iter.next();
+        if (item != null) {
+            iter.remove();
+            return item;
+        }
+        return null;
+    }
+
+    public int size() {
+        return items.size();
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/charstack/CharStackWithArray.java

@@ -0,0 +1,48 @@
+package com.baeldung.charstack;
+
+public class CharStackWithArray {
+
+    private char[] elements;
+    private int size;
+
+    public CharStackWithArray() {
+        size = 0;
+        elements = new char[4];
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public char peek() {
+        if (size == 0) {
+            throw new EmptyStackException();
+        }
+        return elements[size - 1];
+    }
+
+    public char pop() {
+        if (size == 0) {
+            throw new EmptyStackException();
+        }
+
+        return elements[--size];
+    }
+
+    public void push(char item) {
+        ensureCapacity(size + 1);
+        elements[size] = item;
+        size++;
+    }
+
+    private void ensureCapacity(int newSize) {
+        char newBiggerArray[];
+
+        if (elements.length < newSize) {
+            newBiggerArray = new char[elements.length * 2];
+            System.arraycopy(elements, 0, newBiggerArray, 0, size);
+            elements = newBiggerArray;
+        }
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/charstack/EmptyStackException.java

@@ -0,0 +1,9 @@
+package com.baeldung.charstack;
+
+public class EmptyStackException extends RuntimeException {
+
+    public EmptyStackException() {
+        super("Stack is empty");
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/hashtable/Word.java

@@ -0,0 +1,28 @@
+package com.baeldung.hashtable;
+
+public class Word {
+    private String name;
+
+    public Word(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Word))
+            return false;
+
+        Word word = (Word) o;
+        return word.getName().equals(this.name) ? true : false;
+
+    }
+
+    public int hashCode() {
+        return name.hashCode();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/iteratorguide/IteratorGuide.java

@@ -0,0 +1,39 @@
+package com.baeldung.iteratorguide;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class IteratorGuide {
+    
+    public static void main(String[] args) {
+        List<String> items = new ArrayList<>();
+        items.add("ONE");
+        items.add("TWO");
+        items.add("THREE");
+        Iterator<String> iter = items.iterator();
+        while (iter.hasNext()) {
+                String next = iter.next();
+                System.out.println(next);
+                iter.remove();
+        }
+        ListIterator<String> listIterator = items.listIterator();
+        while(listIterator.hasNext()) {
+            String nextWithIndex = items.get(listIterator.nextIndex());
+            String next = listIterator.next();
+            if( "ONE".equals(next)) {
+                listIterator.set("SWAPPED");
+            }
+        }
+        listIterator.add("FOUR");
+        while(listIterator.hasPrevious()) {
+            String previousWithIndex = items.get(listIterator.previousIndex());
+            String previous = listIterator.previous();
+            System.out.println(previous);
+        }
+        listIterator.forEachRemaining(e -> {
+            System.out.println(e);
+        });
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/CopyOnWriteBenchmark.java

@@ -0,0 +1,78 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class CopyOnWriteBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        CopyOnWriteArrayList<Employee> employeeList = new CopyOnWriteArrayList<>();
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeList.add(new Employee(i, "John"));
+            }
+
+            employeeList.add(employee);
+
+            employeeIndex = employeeList.indexOf(employee);
+        }
+    }
+
+        @Benchmark
+    public void testAdd(CopyOnWriteBenchmark.MyState state) {
+            state.employeeList.add(new Employee(state.iterations + 1, "John"));
+    }
+
+    @Benchmark
+    public void testAddAt(CopyOnWriteBenchmark.MyState state) {
+        state.employeeList.add((int) (state.iterations), new Employee(state.iterations, "John"));
+    }
+
+    @Benchmark
+    public boolean testContains(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.contains(state.employee);
+    }
+
+    @Benchmark
+    public int testIndexOf(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.indexOf(state.employee);
+    }
+
+    @Benchmark
+    public Employee testGet(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.get(state.employeeIndex);
+    }
+
+    @Benchmark
+    public boolean testRemove(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.remove(state.employee);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(CopyOnWriteBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/Employee.java

@@ -0,0 +1,55 @@
+package com.baeldung.performance;
+
+public class Employee {
+
+    private Long id;
+    private String name;
+
+    public Employee(Long id, String name) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Employee employee = (Employee) o;
+
+        if (!id.equals(employee.id)) return false;
+        return name.equals(employee.name);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = id.hashCode();
+        result = 31 * result + name.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/HashMapBenchmark.java

@@ -0,0 +1,73 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class HashMapBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        Map<Long, Employee> employeeMap = new HashMap<>();
+        //LinkedHashMap<Long, Employee> employeeMap = new LinkedHashMap<>();
+        //IdentityHashMap<Long, Employee> employeeMap = new IdentityHashMap<>();
+        //WeakHashMap<Long, Employee> employeeMap = new WeakHashMap<>();
+        //ConcurrentHashMap<Long, Employee> employeeMap = new ConcurrentHashMap<>();
+        //ConcurrentSkipListMap<Long, Employee> employeeMap = new ConcurrentSkipListMap <>();
+
+        // TreeMap
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeMap.put(i, new Employee(i, "John"));
+            }
+
+            //employeeMap.put(iterations, employee);
+        }
+    }
+
+    @Benchmark
+    public Employee testGet(HashMapBenchmark.MyState state) {
+        return state.employeeMap.get(state.iterations);
+    }
+
+    @Benchmark
+    public Employee testRemove(HashMapBenchmark.MyState state) {
+        return state.employeeMap.remove(state.iterations);
+    }
+
+    @Benchmark
+    public Employee testPut(HashMapBenchmark.MyState state) {
+        return state.employeeMap.put(state.employee.getId(), state.employee);
+    }
+
+    @Benchmark
+    public Boolean testContainsKey(HashMapBenchmark.MyState state) {
+        return state.employeeMap.containsKey(state.employee.getId());
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(HashMapBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/SetBenchMark.java

@@ -0,0 +1,66 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.ConcurrentSkipListSet;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class SetBenchMark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        //Set<Employee> employeeSet = new HashSet<>();
+        LinkedHashSet<Employee> employeeSet = new LinkedHashSet<>();
+        //ConcurrentSkipListSet<Employee> employeeSet = new ConcurrentSkipListSet <>();
+
+        // TreeSet 
+
+        long iterations = 1000;
+        Employee employee = new Employee(100L, "Harry");
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeSet.add(new Employee(i, "John"));
+            }
+
+            //employeeSet.add(employee);
+        }
+    }
+
+    @Benchmark
+    public boolean testAdd(SetBenchMark.MyState state) {
+        return state.employeeSet.add(state.employee);
+    }
+
+    @Benchmark
+    public Boolean testContains(SetBenchMark.MyState state) {
+        return state.employeeSet.contains(state.employee);
+    }
+
+    @Benchmark
+    public boolean testRemove(SetBenchMark.MyState state) {
+        return state.employeeSet.remove(state.employee);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(SetBenchMark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/queueInterface/CustomBaeldungQueue.java

@@ -0,0 +1,48 @@
+package com.baeldung.queueInterface;
+
+import java.util.AbstractQueue;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class CustomBaeldungQueue<T> extends AbstractQueue<T> {
+
+  private LinkedList<T> elements;
+
+  public CustomBaeldungQueue() {
+    this.elements = new LinkedList<T>();
+  }
+
+  @Override
+  public Iterator<T> iterator() {
+    return elements.iterator();
+  }
+
+  @Override
+  public int size() {
+    return elements.size();
+  }
+
+  @Override
+  public boolean offer(T t) {
+    if(t == null) return false;
+    elements.add(t);
+    return true;
+  }
+
+  @Override
+  public T poll() {
+
+    Iterator<T> iter = elements.iterator();
+    T t = iter.next();
+    if(t != null){
+      iter.remove();
+      return t;
+    }
+    return null;
+  }
+
+  @Override
+  public T peek() {
+    return elements.getFirst();
+  }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/synchronizedcollections/Application.java

@@ -0,0 +1,18 @@
+package com.baeldung.synchronizedcollections;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
+
+public class Application {
+
+    private static final Logger LOGGER = Logger.getLogger(Application.class.getName());
+    
+    public static void main(String[] args) throws InterruptedException {
+        List<Integer> syncCollection = Collections.synchronizedList(Arrays.asList(1, 2, 3, 4, 5, 6));
+        synchronized (syncCollection) {
+            syncCollection.forEach((e) -> {LOGGER.info(e.toString());});
+        }
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/thread_safe_lifo/DequeBasedSynchronizedStack.java

@@ -0,0 +1,36 @@
+package com.baeldung.thread_safe_lifo;
+
+import java.util.ArrayDeque;
+
+/**
+ * Deque Based Stack implementation.
+ */
+public class DequeBasedSynchronizedStack<T> {
+
+    // Internal Deque which gets decorated for synchronization.
+    private ArrayDeque<T> dequeStore = new ArrayDeque<>();
+
+    public DequeBasedSynchronizedStack(int initialCapacity) {
+        this.dequeStore = new ArrayDeque<>(initialCapacity);
+    }
+
+    public DequeBasedSynchronizedStack() {
+
+    }
+
+    public synchronized T pop() {
+        return this.dequeStore.pop();
+    }
+
+    public synchronized void push(T element) {
+        this.dequeStore.push(element);
+    }
+
+    public synchronized T peek() {
+        return this.dequeStore.peek();
+    }
+
+    public synchronized int size() {
+        return this.dequeStore.size();
+    }
+}

core-java-modules/core-java-collections/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>