Merge branch 'master' of github.com:eugenp/tutorials

2018-10-25 08:17:09 +05:30
parent 64c040ce72 5140bd630d
commit 121969da27
792 changed files with 11413 additions and 2334 deletions
@@ -62,3 +62,5 @@ jmeter/src/main/resources/*-JMeter.csv
 **/dist
 **/tmp
 **/out-tsc
+**/nbproject/
+**/nb-configuration.xml
@@ -4,7 +4,7 @@ before_install:
  - echo "MAVEN_OPTS='-Xmx2048M -Xss128M -XX:+CMSClassUnloadingEnabled -XX:+UseG1GC -XX:-UseGCOverheadLimit'" > ~/.mavenrc

 install: skip
-script: travis_wait 60 mvn -q install -Pdefault
+script: travis_wait 60 mvn -q install -Pdefault-first,default-second

 sudo: required

@@ -2,41 +2,37 @@
 The "REST with Spring" Classes
 ==============================

-Here's the Master Class of REST With Spring (price changes permanently next Friday): <br/>
-**[>> THE REST WITH SPRING MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
+Here's the Master Class of REST With Spring (along with the newly announced Boot 2 material): <br/>
+**[>> THE REST WITH SPRING - MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**

 And here's the Master Class of Learn Spring Security: <br/>
-**[>> LEARN SPRING SECURITY MASTER CLASS](http://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
+**[>> LEARN SPRING SECURITY - MASTER CLASS](http://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**



-Spring Tutorials
+Java and Spring Tutorials
 ================

-This project is **a collection of small and focused tutorials** each covering a single and well defined area of development. 
-Most of the tutorial projects are focused on the `Spring Framework` (and `Spring Security`).  
+This project is **a collection of small and focused tutorials** - each covering a single and well defined area of development in the Java ecosystem. 
+A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Securiyt. 
 In additional to Spring, the following technologies are in focus: `core Java`, `Jackson`, `HttpClient`, `Guava`. 

+
 Building the project
 ====================
 To do the full build, do: `mvn install -Pdefault -Dgib.enabled=false`


-Working with the code in Eclipse
-================================
-Any IDE can be used to work with the projects, but if you're using Eclipse, consider the following. 
+Building a single module
+====================
+To build a specific module run the command: `mvn clean install -Dgib.enabled=false` in the module directory

- import the included **formatter** in Eclipse: 
-`https://github.com/eugenp/tutorials/tree/master/eclipse`
+
+Running a Spring Boot module
+====================
+To run a Spring Boot module run the command: `mvn spring-boot:run -Dgib.enabled=false` in the module directory
+


-CI - Jenkins
-================================
-This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/tutorials-unit/)**

-### Relevant Articles: 
-================================

- [Apache Maven Standard Directory Layout](http://www.baeldung.com/maven-directory-structure)
- [Apache Maven Tutorial](http://www.baeldung.com/maven)
- [Designing a User Friendly Java Library](http://www.baeldung.com/design-a-user-friendly-java-library)
@@ -28,3 +28,9 @@
 - [Calculate the Distance Between Two Points in Java](https://www.baeldung.com/java-distance-between-two-points)
 - [Find the Intersection of Two Lines in Java](https://www.baeldung.com/java-intersection-of-two-lines)
 - [Check If a String Contains All The Letters of The Alphabet](https://www.baeldung.com/java-string-contains-all-letters)
+- [Round Up to the Nearest Hundred](https://www.baeldung.com/java-round-up-nearest-hundred)
+- [Merge Sort in Java](https://www.baeldung.com/java-merge-sort)
+- [Calculate Percentage in Java](https://www.baeldung.com/java-calculate-percentage)
+- [Quicksort Algorithm Implementation in Java](https://www.baeldung.com/java-quicksort)
+- [Insertion Sort in Java](https://www.baeldung.com/java-insertion-sort)
+- [Converting Between Byte Arrays and Hexadecimal Strings in Java](https://www.baeldung.com/java-byte-arrays-hex-strings)
@@ -17,6 +17,11 @@
            <artifactId>commons-math3</artifactId>
            <version>${commons-math3.version}</version>
        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
@@ -85,6 +90,7 @@
        <io.jenetics.version>3.7.0</io.jenetics.version>
        <org.jgrapht.core.version>1.0.1</org.jgrapht.core.version>
        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-codec.version>1.11</commons-codec.version>
    </properties>

 </project>
@@ -7,7 +7,7 @@ public class BubbleSort {
    void bubbleSort(Integer[] arr) {
        int n = arr.length;
        IntStream.range(0, n - 1)
-          .flatMap(i -> IntStream.range(i + 1, n - i))
+          .flatMap(i -> IntStream.range(1, n - i))
          .forEach(j -> {
              if (arr[j - 1] > arr[j]) {
                  int temp = arr[j];
@@ -0,0 +1,110 @@
+package com.baeldung.algorithms.conversion;
+
+import java.math.BigInteger;
+
+import javax.xml.bind.DatatypeConverter;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+
+import com.google.common.io.BaseEncoding;
+
+public class HexStringConverter {
+
+    /**
+     * Create a byte Array from String of hexadecimal digits using Character conversion 
+     * @param hexString - Hexadecimal digits as String
+     * @return Desired byte Array
+     */
+    public byte[] decodeHexString(String hexString) {
+        if (hexString.length() % 2 == 1) {
+            throw new IllegalArgumentException("Invalid hexadecimal String supplied.");
+        }
+        byte[] bytes = new byte[hexString.length() / 2];
+
+        for (int i = 0; i < hexString.length(); i += 2) {
+            bytes[i / 2] = hexToByte(hexString.substring(i, i + 2));
+        }
+        return bytes;
+    }
+
+    /**
+     * Create a String of hexadecimal digits from a byte Array using Character conversion
+     * @param byteArray - The byte Array
+     * @return Desired String of hexadecimal digits in lower case
+     */
+    public String encodeHexString(byte[] byteArray) {
+        StringBuffer hexStringBuffer = new StringBuffer();
+        for (int i = 0; i < byteArray.length; i++) {
+            hexStringBuffer.append(byteToHex(byteArray[i]));
+        }
+        return hexStringBuffer.toString();
+    }
+
+    public String byteToHex(byte num) {
+        char[] hexDigits = new char[2];
+        hexDigits[0] = Character.forDigit((num >> 4) & 0xF, 16);
+        hexDigits[1] = Character.forDigit((num & 0xF), 16);
+        return new String(hexDigits);
+    }
+
+    public byte hexToByte(String hexString) {
+        int firstDigit = toDigit(hexString.charAt(0));
+        int secondDigit = toDigit(hexString.charAt(1));
+        return (byte) ((firstDigit << 4) + secondDigit);
+    }
+
+    private int toDigit(char hexChar) {
+        int digit = Character.digit(hexChar, 16);
+        if(digit == -1) {
+            throw new IllegalArgumentException("Invalid Hexadecimal Character: "+ hexChar);
+        }
+        return digit;
+    }
+
+    public String encodeUsingBigIntegerToString(byte[] bytes) {
+        BigInteger bigInteger = new BigInteger(1, bytes);
+        return bigInteger.toString(16);
+    }
+
+    public String encodeUsingBigIntegerStringFormat(byte[] bytes) {
+        BigInteger bigInteger = new BigInteger(1, bytes);
+        return String.format("%0" + (bytes.length << 1) + "x", bigInteger);
+    }
+
+    public byte[] decodeUsingBigInteger(String hexString) {
+        byte[] byteArray = new BigInteger(hexString, 16).toByteArray();
+        if (byteArray[0] == 0) {
+            byte[] output = new byte[byteArray.length - 1];
+            System.arraycopy(byteArray, 1, output, 0, output.length);
+            return output;
+        }
+        return byteArray;
+    }
+
+    public String encodeUsingDataTypeConverter(byte[] bytes) {
+        return DatatypeConverter.printHexBinary(bytes);
+    }
+
+    public byte[] decodeUsingDataTypeConverter(String hexString) {
+        return DatatypeConverter.parseHexBinary(hexString);
+    }
+
+    public String encodeUsingApacheCommons(byte[] bytes) throws DecoderException {
+        return Hex.encodeHexString(bytes);
+    }
+
+    public byte[] decodeUsingApacheCommons(String hexString) throws DecoderException {
+        return Hex.decodeHex(hexString);
+    }
+
+    public String encodeUsingGuava(byte[] bytes) {
+        return BaseEncoding.base16()
+            .encode(bytes);
+    }
+
+    public byte[] decodeUsingGuava(String hexString) {
+        return BaseEncoding.base16()
+            .decode(hexString.toUpperCase());
+    }
+}
@@ -0,0 +1,136 @@
+package com.baeldung.algorithms.heapsort;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Heap<E extends Comparable<E>> {
+
+    private List<E> elements = new ArrayList<>();
+
+    public static <E extends Comparable<E>> List<E> sort(Iterable<E> elements) {
+        Heap<E> heap = of(elements);
+
+        List<E> result = new ArrayList<>();
+
+        while (!heap.isEmpty()) {
+            result.add(heap.pop());
+        }
+
+        return result;
+    }
+
+    public static <E extends Comparable<E>> Heap<E> of(E... elements) {
+        return of(Arrays.asList(elements));
+    }
+
+    public static <E extends Comparable<E>> Heap<E> of(Iterable<E> elements) {
+        Heap<E> result = new Heap<>();
+        for (E element : elements) {
+            result.add(element);
+        }
+        return result;
+    }
+
+    public void add(E e) {
+        elements.add(e);
+        int elementIndex = elements.size() - 1;
+        while (!isRoot(elementIndex) && !isCorrectChild(elementIndex)) {
+            int parentIndex = parentIndex(elementIndex);
+            swap(elementIndex, parentIndex);
+            elementIndex = parentIndex;
+        }
+    }
+
+    public E pop() {
+        if (isEmpty()) {
+            throw new IllegalStateException("You cannot pop from an empty heap");
+        }
+
+        E result = elementAt(0);
+
+        int lasElementIndex = elements.size() - 1;
+        swap(0, lasElementIndex);
+        elements.remove(lasElementIndex);
+
+        int elementIndex = 0;
+        while (!isLeaf(elementIndex) && !isCorrectParent(elementIndex)) {
+            int smallerChildIndex = smallerChildIndex(elementIndex);
+            swap(elementIndex, smallerChildIndex);
+            elementIndex = smallerChildIndex;
+        }
+
+        return result;
+    }
+
+    public boolean isEmpty() {
+        return elements.isEmpty();
+    }
+    
+    private boolean isRoot(int index) {
+        return index == 0;
+    }
+
+    private int smallerChildIndex(int index) {
+        int leftChildIndex = leftChildIndex(index);
+        int rightChildIndex = rightChildIndex(index);
+        
+        if (!isValidIndex(rightChildIndex)) {
+            return leftChildIndex;
+        }
+
+        if (elementAt(leftChildIndex).compareTo(elementAt(rightChildIndex)) < 0) {
+            return leftChildIndex;
+        }
+
+        return rightChildIndex;
+    }
+
+    private boolean isLeaf(int index) {
+        return !isValidIndex(leftChildIndex(index));
+    }
+
+    private boolean isCorrectParent(int index) {
+        return isCorrect(index, leftChildIndex(index)) && isCorrect(index, rightChildIndex(index));
+    }
+
+    private boolean isCorrectChild(int index) {
+        return isCorrect(parentIndex(index), index);
+    }
+
+    private boolean isCorrect(int parentIndex, int childIndex) {
+        if (!isValidIndex(parentIndex) || !isValidIndex(childIndex)) {
+            return true;
+        }
+
+        return elementAt(parentIndex).compareTo(elementAt(childIndex)) < 0;
+    }
+
+    private boolean isValidIndex(int index) {
+        return index < elements.size();
+    }
+
+    private void swap(int index1, int index2) {
+        E element1 = elementAt(index1);
+        E element2 = elementAt(index2);
+        elements.set(index1, element2);
+        elements.set(index2, element1);
+    }
+
+    private E elementAt(int index) {
+        return elements.get(index);
+    }
+
+    private int parentIndex(int index) {
+        return (index - 1) / 2;
+    }
+
+    private int leftChildIndex(int index) {
+        return 2 * index + 1;
+    }
+
+    private int rightChildIndex(int index) {
+        return 2 * index + 2;
+    }
+
+}
@@ -0,0 +1,41 @@
+package com.baeldung.algorithms.insertionsort;
+
+public class InsertionSort {
+
+    public static void insertionSortImperative(int[] input) {
+        for (int i = 1; i < input.length; i++) {
+            int key = input[i];
+            int j = i - 1;
+            while (j >= 0 && input[j] > key) {
+                input[j + 1] = input[j];
+                j = j - 1;
+            }
+            input[j + 1] = key;
+        }
+    }
+
+    public static void insertionSortRecursive(int[] input) {
+        insertionSortRecursive(input, input.length);
+    }
+
+    private static void insertionSortRecursive(int[] input, int i) {
+        // base case
+        if (i <= 1) {
+            return;
+        }
+
+        // sort the first i - 1 elements of the array
+        insertionSortRecursive(input, i - 1);
+
+        // then find the correct position of the element at position i
+        int key = input[i - 1];
+        int j = i - 2;
+        // shifting the elements from their position by 1
+        while (j >= 0 && input[j] > key) {
+            input[j + 1] = input[j];
+            j = j - 1;
+        }
+        // inserting the key at the appropriate position
+        input[j + 1] = key;
+    }
+}
@@ -98,7 +98,7 @@ public class FindKthLargest {

    private int randomPartition(Integer arr[], int left, int right) {
        int n = right - left + 1;
-        int pivot = (int) (Math.random()) % n;
+        int pivot = (int) (Math.random() * n);
        swap(arr, left + pivot, right);
        return partition(arr, left, right);
    }
@@ -1,8 +1,8 @@
 package com.baeldung.algorithms.bubblesort;

-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;

-import org.junit.Test;
+import org.junit.jupiter.api.Test;

 public class BubbleSortUnitTest {

@@ -0,0 +1,127 @@
+package com.baeldung.algorithms.conversion;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import org.apache.commons.codec.DecoderException;
+import org.hamcrest.text.IsEqualIgnoringCase;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.algorithms.conversion.HexStringConverter;
+
+public class ByteArrayConverterUnitTest {
+
+    private HexStringConverter hexStringConverter;
+
+    @Before
+    public void setup() {
+        hexStringConverter = new HexStringConverter();
+    }
+
+    @Test
+    public void shouldEncodeByteArrayToHexStringUsingBigIntegerToString() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        if(hexString.charAt(0) == '0') {
+            hexString = hexString.substring(1);
+        }
+        String output = hexStringConverter.encodeUsingBigIntegerToString(bytes);
+        assertThat(output, IsEqualIgnoringCase.equalToIgnoringCase(hexString));
+    }
+
+    @Test
+    public void shouldEncodeByteArrayToHexStringUsingBigIntegerStringFormat() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        String output = hexStringConverter.encodeUsingBigIntegerStringFormat(bytes);
+        assertThat(output, IsEqualIgnoringCase.equalToIgnoringCase(hexString));
+    }
+
+    @Test
+    public void shouldDecodeHexStringToByteArrayUsingBigInteger() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        byte[] output = hexStringConverter.decodeUsingBigInteger(hexString);
+        assertArrayEquals(bytes, output);
+    }
+    
+    @Test
+    public void shouldEncodeByteArrayToHexStringUsingCharacterConversion() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        String output = hexStringConverter.encodeHexString(bytes);
+        assertThat(output, IsEqualIgnoringCase.equalToIgnoringCase(hexString));
+    }
+
+    @Test
+    public void shouldDecodeHexStringToByteArrayUsingCharacterConversion() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        byte[] output = hexStringConverter.decodeHexString(hexString);
+        assertArrayEquals(bytes, output);
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void shouldDecodeHexToByteWithInvalidHexCharacter() {
+        hexStringConverter.hexToByte("fg");
+    }
+
+    @Test
+    public void shouldEncodeByteArrayToHexStringDataTypeConverter() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        String output = hexStringConverter.encodeUsingDataTypeConverter(bytes);
+        assertThat(output, IsEqualIgnoringCase.equalToIgnoringCase(hexString));
+    }
+
+    @Test
+    public void shouldDecodeHexStringToByteArrayUsingDataTypeConverter() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        byte[] output = hexStringConverter.decodeUsingDataTypeConverter(hexString);
+        assertArrayEquals(bytes, output);
+    }
+
+    @Test
+    public void shouldEncodeByteArrayToHexStringUsingGuava() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        String output = hexStringConverter.encodeUsingGuava(bytes);
+        assertThat(output, IsEqualIgnoringCase.equalToIgnoringCase(hexString));
+    }
+
+    @Test
+    public void shouldDecodeHexStringToByteArrayUsingGuava() {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        byte[] output = hexStringConverter.decodeUsingGuava(hexString);
+        assertArrayEquals(bytes, output);
+    }
+
+    @Test
+    public void shouldEncodeByteArrayToHexStringUsingApacheCommons() throws DecoderException {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        String output = hexStringConverter.encodeUsingApacheCommons(bytes);
+        assertThat(output, IsEqualIgnoringCase.equalToIgnoringCase(hexString));
+    }
+
+    @Test
+    public void shouldDecodeHexStringToByteArrayUsingApacheCommons() throws DecoderException {
+        byte[] bytes = getSampleBytes();
+        String hexString = getSampleHexString();
+        byte[] output = hexStringConverter.decodeUsingApacheCommons(hexString);
+        assertArrayEquals(bytes, output);
+    }
+
+    private String getSampleHexString() {
+        return "0af50c0e2d10";
+    }
+
+    private byte[] getSampleBytes() {
+        return new byte[] { 10, -11, 12, 14, 45, 16 };
+    }
+
+}
@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.heapsort;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+
+public class HeapUnitTest {
+
+    @Test
+    public void givenNotEmptyHeap_whenPopCalled_thenItShouldReturnSmallestElement() {
+        // given
+        Heap<Integer> heap = Heap.of(3, 5, 1, 4, 2);
+
+        // when
+        int head = heap.pop();
+
+        // then
+        assertThat(head).isEqualTo(1);
+    }
+    
+    @Test
+    public void givenNotEmptyIterable_whenSortCalled_thenItShouldReturnElementsInSortedList() {
+        // given
+        List<Integer> elements = Arrays.asList(3, 5, 1, 4, 2);
+        
+        // when
+        List<Integer> sortedElements = Heap.sort(elements);
+        
+        // then
+        assertThat(sortedElements).isEqualTo(Arrays.asList(1, 2, 3, 4, 5));
+    }
+
+}
@@ -0,0 +1,25 @@
+package com.baeldung.algorithms.insertionsort;
+
+import com.baeldung.algorithms.insertionsort.InsertionSort;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class InsertionSortUnitTest {
+
+    @Test
+    public void givenUnsortedArray_whenInsertionSortImperative_thenSortedAsc() {
+        int[] input = {6, 2, 3, 4, 5, 1};
+        InsertionSort.insertionSortImperative(input);
+        int[] expected = {1, 2, 3, 4, 5, 6};
+        assertArrayEquals("the two arrays are not equal", expected, input);
+    }
+
+    @Test
+    public void givenUnsortedArray_whenInsertionSortRecursive_thenSortedAsc() {
+        int[] input = {6, 4, 5, 2, 3, 1};
+        InsertionSort.insertionSortRecursive(input);
+        int[] expected = {1, 2, 3, 4, 5, 6};
+        assertArrayEquals("the two arrays are not equal", expected, input);
+    }
+}
@@ -0,0 +1,3 @@
+### Relevant Articles: 
+
+- [A Quick Guide to Apache Geode](https://www.baeldung.com/apache-geode)
@@ -0,0 +1,8 @@
+.classpath
+.project
+.settings
+target
+.idea
+*.iml
+.gradle/
+build/
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.baeldung.pulsar</groupId>
+  <artifactId>pulsar-java</artifactId>
+  <version>0.0.1</version>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.pulsar</groupId>
+      <artifactId>pulsar-client</artifactId>
+      <version>2.1.1-incubating</version>
+      <scope>compile</scope>
+    </dependency>
+  </dependencies>
+  <properties>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+  </properties>
+</project>
@@ -0,0 +1,48 @@
+package com.baeldung;
+
+import java.io.IOException;
+
+import org.apache.pulsar.client.api.Consumer;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.SubscriptionType;
+
+public class ConsumerTest {
+
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "test-topic";
+    private static final String SUBSCRIPTION_NAME = "test-subscription";
+
+    public static void main(String[] args) throws IOException {
+        // Create a Pulsar client instance. A single instance can be shared across many
+        // producers and consumer within the same application
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        //Configure consumer specific settings.
+        Consumer<byte[]> consumer = client.newConsumer()
+                .topic(TOPIC_NAME)
+                // Allow multiple consumers to attach to the same subscription
+                // and get messages dispatched as a queue
+                .subscriptionType(SubscriptionType.Shared)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscribe();
+
+
+        // Once the consumer is created, it can be used for the entire application lifecycle
+        System.out.println("Created consumer for the topic "+ TOPIC_NAME);
+
+        do {
+            // Wait until a message is available
+            Message<byte[]> msg = consumer.receive();
+
+            // Extract the message as a printable string and then log
+            String content = new String(msg.getData());
+            System.out.println("Received message '"+content+"' with ID "+msg.getMessageId());
+
+            // Acknowledge processing of the message so that it can be deleted
+            consumer.acknowledge(msg);
+        } while (true);
+    }
+}
@@ -0,0 +1,58 @@
+package com.baeldung;
+
+import org.apache.pulsar.client.api.CompressionType;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.MessageBuilder;
+import org.apache.pulsar.client.api.MessageId;
+import org.apache.pulsar.client.api.Producer;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.PulsarClientException;
+
+import java.io.IOException;
+import java.util.stream.IntStream;
+
+public class ProducerTest {
+
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "test-topic";
+
+    public static void main(String[] args) throws IOException {
+        // Create a Pulsar client instance. A single instance can be shared across many
+        // producers and consumer within the same application
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        // Configure producer specific settings
+        Producer<byte[]> producer = client.newProducer()
+                // Set the topic
+                .topic(TOPIC_NAME)
+                // Enable compression
+                .compressionType(CompressionType.LZ4)
+                .create();
+
+        // Once the producer is created, it can be used for the entire application life-cycle
+        System.out.println("Created producer for the topic "+TOPIC_NAME);
+
+        // Send 5 test messages
+        IntStream.range(1, 5).forEach(i -> {
+            String content = String.format("hi-pulsar-%d", i);
+
+            // Build a message object
+            Message<byte[]> msg = MessageBuilder.create()
+                    .setContent(content.getBytes())
+                    .build();
+
+            // Send each message and log message content and ID when successfully received
+            try {
+                MessageId msgId = producer.send(msg);
+
+                System.out.println("Published message '"+content+"' with the ID "+msgId);
+            } catch (PulsarClientException e) {
+                System.out.println(e.getMessage());
+            }
+        });
+
+        client.close();
+    }
+}
@@ -0,0 +1,59 @@
+package com.baeldung.subscriptions;
+
+import org.apache.pulsar.client.api.ConsumerBuilder;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.MessageBuilder;
+import org.apache.pulsar.client.api.Producer;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.PulsarClientException;
+import org.apache.pulsar.client.api.SubscriptionType;
+
+import java.util.stream.IntStream;
+
+public class ExclusiveSubscriptionTest {
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "test-topic";
+    private static final String SUBSCRIPTION_NAME = "test-subscription";
+    private static final SubscriptionType SUBSCRIPTION_TYPE = SubscriptionType.Exclusive;
+
+    public static void main(String[] args) throws PulsarClientException {
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        Producer<byte[]> producer = client.newProducer()
+                .topic(TOPIC_NAME)
+                .create();
+
+        ConsumerBuilder<byte[]> consumer1 = client.newConsumer()
+                .topic(TOPIC_NAME)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscriptionType(SUBSCRIPTION_TYPE);
+
+        ConsumerBuilder<byte[]> consumer2 = client.newConsumer()
+                .topic(TOPIC_NAME)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscriptionType(SUBSCRIPTION_TYPE);
+
+        IntStream.range(0, 999).forEach(i -> {
+            Message<byte[]> msg = MessageBuilder.create()
+                    .setContent(String.format("message-%d", i).getBytes())
+                    .build();
+            try {
+                producer.send(msg);
+            } catch (PulsarClientException e) {
+                System.out.println(e.getMessage());
+            }
+        });
+
+        // Consumer 1 can subscribe to the topic
+        consumer1.subscribe();
+
+        // Consumer 2 cannot due to the exclusive subscription held by consumer 1
+        consumer2.subscribeAsync()
+                .handle((consumer, exception) -> {
+                    System.out.println(exception.getMessage());
+                    return null;
+                });
+    }
+}
@@ -0,0 +1,76 @@
+package com.baeldung.subscriptions;
+
+import org.apache.pulsar.client.api.Consumer;
+import org.apache.pulsar.client.api.ConsumerBuilder;
+import org.apache.pulsar.client.api.Message;
+import org.apache.pulsar.client.api.MessageBuilder;
+import org.apache.pulsar.client.api.Producer;
+import org.apache.pulsar.client.api.PulsarClient;
+import org.apache.pulsar.client.api.PulsarClientException;
+import org.apache.pulsar.client.api.SubscriptionType;
+
+import java.util.stream.IntStream;
+
+public class FailoverSubscriptionTest {
+    private static final String SERVICE_URL = "pulsar://localhost:6650";
+    private static final String TOPIC_NAME = "failover-subscription-test-topic";
+    private static final String SUBSCRIPTION_NAME = "test-subscription";
+    private static final SubscriptionType SUBSCRIPTION_TYPE = SubscriptionType.Failover;
+    private static final int NUM_MSGS = 10;
+
+    public static void main(String[] args) throws PulsarClientException {
+        PulsarClient client = PulsarClient.builder()
+                .serviceUrl(SERVICE_URL)
+                .build();
+
+        Producer<byte[]> producer = client.newProducer()
+                .topic(TOPIC_NAME)
+                .create();
+
+        ConsumerBuilder<byte[]> consumerBuilder = client.newConsumer()
+                .topic(TOPIC_NAME)
+                .subscriptionName(SUBSCRIPTION_NAME)
+                .subscriptionType(SUBSCRIPTION_TYPE);
+
+        Consumer<byte[]> mainConsumer = consumerBuilder
+                .consumerName("consumer-a")
+                .messageListener((consumer, msg) -> {
+                    System.out.println("Message received by main consumer");
+
+                    try {
+                        consumer.acknowledge(msg);
+                    } catch (PulsarClientException e) {
+                        System.out.println(e.getMessage());
+                    }
+                })
+                .subscribe();
+
+        Consumer<byte[]> failoverConsumer = consumerBuilder
+                .consumerName("consumer-b")
+                .messageListener((consumer, msg) -> {
+                    System.out.println("Message received by failover consumer");
+
+                    try {
+                        consumer.acknowledge(msg);
+                    } catch (PulsarClientException e) {
+                        System.out.println(e.getMessage());
+                    }
+                })
+                .subscribe();
+
+        IntStream.range(0, NUM_MSGS).forEach(i -> {
+            Message<byte[]> msg = MessageBuilder.create()
+                    .setContent(String.format("message-%d", i).getBytes())
+                    .build();
+            try {
+                producer.send(msg);
+
+                Thread.sleep(100);
+
+                if (i > 5) mainConsumer.close();
+            } catch (InterruptedException | PulsarClientException e) {
+                System.out.println(e.getMessage());
+            }
+        });
+    }
+}
@@ -9,4 +9,4 @@
 - [Integration Testing with a Local DynamoDB Instance](http://www.baeldung.com/dynamodb-local-integration-tests)
 - [Using the JetS3t Java Client With Amazon S3](http://www.baeldung.com/jets3t-amazon-s3)
 - [Managing Amazon SQS Queues in Java](http://www.baeldung.com/aws-queues-java)
-
+- [Guide to AWS Aurora RDS with Java](https://www.baeldung.com/aws-aurora-rds-java)
@@ -32,3 +32,4 @@
 - [Set the Time Zone of a Date in Java](https://www.baeldung.com/java-set-date-time-zone)
 - [An Overview of Regular Expressions Performance in Java](https://www.baeldung.com/java-regex-performance)
 - [Java Primitives versus Objects](https://www.baeldung.com/java-primitives-vs-objects)
+- [How to Use if/else Logic in Java 8 Streams](https://www.baeldung.com/java-8-streams-if-else-logic)
@@ -1,46 +0,0 @@
-package com.baeldung.internationalization;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.time.LocalDateTime;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Locale;
-import java.util.TimeZone;
-
-public class DateTimeFormatterUnitTest {
-
-    @Test
-    public void givenDefaultUsLocaleAndDateTimeAndPattern_whenFormatWithDifferentLocales_thenGettingLocalizedDateTimes() {
-        Locale.setDefault(Locale.US);
-        LocalDateTime localDateTime = LocalDateTime.of(2018, 1, 1, 10, 15, 50, 500);
-        String pattern = "dd-MMMM-yyyy HH:mm:ss.SSS";
-
-        DateTimeFormatter defaultTimeFormatter = DateTimeFormatter.ofPattern(pattern);
-        DateTimeFormatter plTimeFormatter = DateTimeFormatter.ofPattern(pattern, new Locale("pl", "PL"));
-        DateTimeFormatter deTimeFormatter = DateTimeFormatter.ofPattern(pattern).withLocale(Locale.GERMANY);
-
-        Assert.assertEquals("01-January-2018 10:15:50.000", defaultTimeFormatter.format(localDateTime));
-        Assert.assertEquals("01-stycznia-2018 10:15:50.000", plTimeFormatter.format(localDateTime));
-        Assert.assertEquals("01-Januar-2018 10:15:50.000", deTimeFormatter.format(localDateTime));
-    }
-
-    @Test
-    public void givenDateTimeAndTimeZone_whenFormatWithDifferentLocales_thenGettingLocalizedZonedDateTimes() {
-        Locale.setDefault(Locale.US);
-        LocalDateTime localDateTime = LocalDateTime.of(2018, 1, 1, 10, 15, 50, 500);
-        ZoneId losAngelesTimeZone = TimeZone.getTimeZone("America/Los_Angeles").toZoneId();
-
-        DateTimeFormatter localizedFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);
-        DateTimeFormatter frLocalizedFormatter =
-                DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withLocale(Locale.FRANCE);
-        String formattedDateTime = localizedFormatter.format(ZonedDateTime.of(localDateTime, losAngelesTimeZone));
-        String frFormattedDateTime = frLocalizedFormatter.format(ZonedDateTime.of(localDateTime, losAngelesTimeZone));
-
-        Assert.assertEquals("Monday, January 1, 2018 10:15:50 AM PST", formattedDateTime);
-        Assert.assertEquals("lundi 1 janvier 2018 10 h 15 PST", frFormattedDateTime);
-    }
-}
@@ -1,16 +1,18 @@
 package com.baeldung.java8;

-import com.baeldung.java8.entity.Human;
-import com.google.common.collect.Lists;
-import com.google.common.primitives.Ints;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.hamcrest.Matchers.equalTo;

 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.stream.Collectors;

-import static org.hamcrest.Matchers.equalTo;
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.java8.entity.Human;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;

 public class Java8SortUnitTest {

@@ -111,5 +113,22 @@ public class Java8SortUnitTest {
        humans.sort(Comparator.comparing(Human::getName));
        Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
    }
+    
+    @Test
+    public final void givenStreamNaturalOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<String> letters = Lists.newArrayList("B", "A", "C");
+        
+        final List<String> sortedLetters = letters.stream().sorted().collect(Collectors.toList());
+        Assert.assertThat(sortedLetters.get(0), equalTo("A"));
+    }

+    @Test
+    public final void givenStreamCustomOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+        final Comparator<Human> nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
+        
+        final List<Human> sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList());
+        Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
+    }
 }
@@ -26,3 +26,4 @@
 - [Iterate Through a Range of Dates in Java](https://www.baeldung.com/java-iterate-date-range)
 - [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
 - [Java 9 Platform Logging API](https://www.baeldung.com/java-9-logging-api)
+- [Guide to java.lang.Process API](https://www.baeldung.com/java-process-api)
@@ -4,37 +4,23 @@

 ### Relevant Articles: 
 - [Immutable ArrayList in Java](http://www.baeldung.com/java-immutable-list)
- [Converting between an Array and a List in Java](http://www.baeldung.com/convert-array-to-list-and-list-to-array)
- [Converting between an Array and a Set in Java](http://www.baeldung.com/convert-array-to-set-and-set-to-array)
- [Converting between a List and a Set in Java](http://www.baeldung.com/convert-list-to-set-and-set-to-list)
- [Convert a Map to an Array, List or Set in Java](http://www.baeldung.com/convert-map-values-to-array-list-set)
 - [Guide to the Java ArrayList](http://www.baeldung.com/java-arraylist)
 - [Random List Element](http://www.baeldung.com/java-random-list-element)
 - [Java - Combine Multiple Collections](http://www.baeldung.com/java-combine-multiple-collections)
- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
- [Guide to the Guava BiMap](http://www.baeldung.com/guava-bimap)
- [The Java HashMap Under the Hood](http://www.baeldung.com/java-hashmap)
- [A Guide to LinkedHashMap in Java](http://www.baeldung.com/java-linked-hashmap)
- [A Guide to TreeMap in Java](http://www.baeldung.com/java-treemap)
 - [Removing all nulls from a List in Java](http://www.baeldung.com/java-remove-nulls-from-list)
 - [Removing all duplicates from a List in Java](http://www.baeldung.com/java-remove-duplicates-from-list)
 - [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
 - [HashSet and TreeSet Comparison](http://www.baeldung.com/java-hashset-vs-treeset)
- [Iterate over a Map in Java](http://www.baeldung.com/java-iterate-map)
 - [Collect a Java Stream to an Immutable Collection](http://www.baeldung.com/java-stream-immutable-collection)
- [Converting a List to String in Java](http://www.baeldung.com/java-list-to-string)
 - [Introduction to the Java ArrayDeque](http://www.baeldung.com/java-array-deque)
 - [A Guide to HashSet in Java](http://www.baeldung.com/java-hashset)
 - [A Guide to TreeSet in Java](http://www.baeldung.com/java-tree-set)
- [Java TreeMap vs HashMap](http://www.baeldung.com/java-treemap-vs-hashmap)
 - [How to TDD a List Implementation in Java](http://www.baeldung.com/java-test-driven-list)
- [How to Store Duplicate Keys in a Map in Java?](http://www.baeldung.com/java-map-duplicate-keys)
 - [Getting the Size of an Iterable in Java](http://www.baeldung.com/java-iterable-size)
 - [Iterating Backward Through a List](http://www.baeldung.com/java-list-iterate-backwards)
 - [How to Filter a Collection in Java](http://www.baeldung.com/java-collection-filtering)
 - [Add Multiple Items to an Java ArrayList](http://www.baeldung.com/java-add-items-array-list)
 - [Remove the First Element from a List](http://www.baeldung.com/java-remove-first-element-from-list)
- [How to Convert List to Map in Java](http://www.baeldung.com/java-list-to-map)
 - [Initializing HashSet at the Time of Construction](http://www.baeldung.com/java-initialize-hashset)
 - [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
 - [Fail-Safe Iterator vs Fail-Fast Iterator](http://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)
@@ -47,7 +33,9 @@
 - [Remove All Occurrences of a Specific Value from a List](https://www.baeldung.com/java-remove-value-from-list)
 - [Thread Safe LIFO Data Structure Implementations](https://www.baeldung.com/java-lifo-thread-safe)
 - [Collections.emptyList() vs. New List Instance](https://www.baeldung.com/java-collections-emptylist-new-list)
- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
+- [Differences Between Collection.clear() and Collection.removeAll()](https://www.baeldung.com/java-collection-clear-vs-removeall)
 - [Performance of contains() in a HashSet vs ArrayList](https://www.baeldung.com/java-hashset-arraylist-contains-performance)
- [Get the Key for a Value from a Java Map](https://www.baeldung.com/java-map-key-from-value)
 - [Time Complexity of Java Collections](https://www.baeldung.com/java-collections-complexity)
+- [Operating on and Removing an Item from Stream](https://www.baeldung.com/java-use-remove-item-stream)
+- [An Introduction to Synchronized Java Collections](https://www.baeldung.com/java-synchronized-collections)
+- [Guide to EnumSet](https://www.baeldung.com/java-enumset)
@@ -1,85 +1,71 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>com.baeldung</groupId>
-    <artifactId>core-java-collections</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-    <packaging>jar</packaging>
-    <name>core-java-collections</name>
-
-    <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
-        <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-java</relativePath>
-    </parent>
-
-    <dependencies>
-        <dependency>
-            <groupId>net.sourceforge.collections</groupId>
-            <artifactId>collections-generic</artifactId>
-            <version>${collections-generic.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-collections4</artifactId>
-            <version>${commons-collections4.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.jayway.awaitility</groupId>
-            <artifactId>awaitility</artifactId>
-            <version>${avaitility.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-lang3</artifactId>
-            <version>${commons-lang3.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.eclipse.collections</groupId>
-            <artifactId>eclipse-collections</artifactId>
-            <version>${eclipse.collections.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <version>${assertj.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-runner</artifactId>
-            <version>${junit.platform.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openjdk.jmh</groupId>
-            <artifactId>jmh-core</artifactId>
-            <version>${openjdk.jmh.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.openjdk.jmh</groupId>
-            <artifactId>jmh-generator-annprocess</artifactId>
-            <version>${openjdk.jmh.version}</version>
-        </dependency>
-		<dependency>
-		    <groupId>org.apache.commons</groupId>
-		    <artifactId>commons-exec</artifactId>
-		    <version>1.3</version>
-		</dependency>
-		        
-    </dependencies>
-
-
-    <properties>
-        <openjdk.jmh.version>1.19</openjdk.jmh.version>
-        <junit.platform.version>1.2.0</junit.platform.version>
-        <commons-lang3.version>3.5</commons-lang3.version>
-        <commons-collections4.version>4.1</commons-collections4.version>
-        <collections-generic.version>4.01</collections-generic.version>
-        <avaitility.version>1.7.0</avaitility.version>
-        <assertj.version>3.6.1</assertj.version>
-        <eclipse.collections.version>7.1.0</eclipse.collections.version>
-    </properties>
-</project>
+<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>
+    <artifactId>core-java-collections</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>core-java-collections</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.collections</groupId>
+            <artifactId>eclipse-collections</artifactId>
+            <version>${eclipse.collections.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${openjdk.jmh.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${openjdk.jmh.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-exec</artifactId>
+            <version>1.3</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <openjdk.jmh.version>1.19</openjdk.jmh.version>
+        <junit.platform.version>1.2.0</junit.platform.version>
+        <commons-lang3.version>3.5</commons-lang3.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
+        <collections-generic.version>4.01</collections-generic.version>
+        <avaitility.version>1.7.0</avaitility.version>
+        <assertj.version>3.6.1</assertj.version>
+        <eclipse.collections.version>7.1.0</eclipse.collections.version>
+    </properties>
+</project>
@@ -0,0 +1,45 @@
+package com.baeldung.enumset;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+public class EnumSets {
+
+    public enum Color {
+        RED, YELLOW, GREEN, BLUE, BLACK, WHITE
+    }
+
+    public static void main(String[] args) {
+        EnumSet<Color> allColors = EnumSet.allOf(Color.class);
+        System.out.println(allColors);
+
+        EnumSet<Color> noColors = EnumSet.noneOf(Color.class);
+        System.out.println(noColors);
+
+        EnumSet<Color> blackAndWhite = EnumSet.of(Color.BLACK, Color.WHITE);
+        System.out.println(blackAndWhite);
+
+        EnumSet<Color> noBlackOrWhite = EnumSet.complementOf(blackAndWhite);
+        System.out.println(noBlackOrWhite);
+
+        EnumSet<Color> range = EnumSet.range(Color.YELLOW, Color.BLUE);
+        System.out.println(range);
+
+        EnumSet<Color> blackAndWhiteCopy = EnumSet.copyOf(EnumSet.of(Color.BLACK, Color.WHITE));
+        System.out.println(blackAndWhiteCopy);
+
+        List<Color> colorsList = new ArrayList<>();
+        colorsList.add(Color.RED);
+        EnumSet<Color> listCopy = EnumSet.copyOf(colorsList);
+        System.out.println(listCopy);
+
+        EnumSet<Color> set = EnumSet.noneOf(Color.class);
+        set.add(Color.RED);
+        set.add(Color.YELLOW);
+        set.contains(Color.RED);
+        set.forEach(System.out::println);
+        set.remove(Color.RED);
+    }
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class CollectionRemoveIf {
+
+    public static void main(String args[]) {
+        Collection<String> names = new ArrayList<>();
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        names.removeIf(e -> e.startsWith("A"));
+        System.out.println(String.join(",", names));
+    }
+}
--- a/Show More
+++ b/Show More