Merge remote-tracking branch 'eugenp/master'

core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExample.java

@@ -0,0 +1,33 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import java.util.concurrent.CountDownLatch;
+
+public class CountdownLatchCountExample {
+
+    private int count;
+
+    public CountdownLatchCountExample(int count) {
+        this.count = count;
+    }
+
+    public boolean callTwiceInSameThread() {
+        CountDownLatch countDownLatch = new CountDownLatch(count);
+        Thread t = new Thread(() -> {
+            countDownLatch.countDown();
+            countDownLatch.countDown();
+        });
+        t.start();
+
+        try {
+            countDownLatch.await();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return countDownLatch.getCount() == 0;
+    }
+
+    public static void main(String[] args) {
+        CountdownLatchCountExample ex = new CountdownLatchCountExample(2);
+        System.out.println("Is CountDown Completed : " + ex.callTwiceInSameThread());
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java

@@ -0,0 +1,41 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class CountdownLatchResetExample {
+
+    private int count;
+    private int threadCount;
+    private final AtomicInteger updateCount;
+
+    CountdownLatchResetExample(int count, int threadCount) {
+        updateCount = new AtomicInteger(0);
+        this.count = count;
+        this.threadCount = threadCount;
+    }
+
+    public int countWaits() {
+        CountDownLatch countDownLatch = new CountDownLatch(count);
+        ExecutorService es = Executors.newFixedThreadPool(threadCount);
+        for (int i = 0; i < threadCount; i++) {
+            es.execute(() -> {
+                long prevValue = countDownLatch.getCount();
+                countDownLatch.countDown();
+                if (countDownLatch.getCount() != prevValue) {
+                    updateCount.incrementAndGet();
+                }               
+            });
+        }
+        
+        es.shutdown();
+        return updateCount.get();
+    }
+
+    public static void main(String[] args) {
+        CountdownLatchResetExample ex = new CountdownLatchResetExample(5, 20);
+        System.out.println("Count : " + ex.countWaits());
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java

@@ -0,0 +1,45 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class CyclicBarrierCompletionMethodExample {
+
+    private int count;
+    private int threadCount;
+    private final AtomicInteger updateCount;
+    
+    CyclicBarrierCompletionMethodExample(int count, int threadCount) {
+        updateCount = new AtomicInteger(0);
+        this.count = count;
+        this.threadCount = threadCount;
+    }
+
+    public int countTrips() {
+
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(count, () -> {
+            updateCount.incrementAndGet();
+        });
+
+        ExecutorService es = Executors.newFixedThreadPool(threadCount);
+        for (int i = 0; i < threadCount; i++) {
+            es.execute(() -> {
+                try {
+                    cyclicBarrier.await();
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            });
+        }
+        es.shutdown();
+        return updateCount.get();
+    }
+
+    public static void main(String[] args) {
+        CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(5, 20);
+        System.out.println("Count : " + ex.countTrips());
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java

@@ -0,0 +1,32 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+public class CyclicBarrierCountExample {
+
+    private int count;
+
+    public CyclicBarrierCountExample(int count) {
+        this.count = count;
+    }
+
+    public boolean callTwiceInSameThread() {
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(count);
+        Thread t = new Thread(() -> {
+            try {
+                cyclicBarrier.await();
+                cyclicBarrier.await();
+            } catch (InterruptedException | BrokenBarrierException e) {
+                e.printStackTrace();
+            }
+        });
+        t.start();
+        return cyclicBarrier.isBroken();
+    }
+
+    public static void main(String[] args) {
+        CyclicBarrierCountExample ex = new CyclicBarrierCountExample(7);
+        System.out.println("Count : " + ex.callTwiceInSameThread());
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java

@@ -0,0 +1,46 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class CyclicBarrierResetExample {
+
+    private int count;
+    private int threadCount;
+    private final AtomicInteger updateCount;
+
+    CyclicBarrierResetExample(int count, int threadCount) {
+        updateCount = new AtomicInteger(0);
+        this.count = count;
+        this.threadCount = threadCount;
+    }
+
+    public int countWaits() {
+
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(count);
+
+        ExecutorService es = Executors.newFixedThreadPool(threadCount);
+        for (int i = 0; i < threadCount; i++) {
+            es.execute(() -> {
+                try {
+                    if (cyclicBarrier.getNumberWaiting() > 0) {
+                        updateCount.incrementAndGet();
+                    }   
+                    cyclicBarrier.await();
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            });
+        }
+        es.shutdown();
+        return updateCount.get();
+    }
+
+    public static void main(String[] args) {
+        CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7, 20);
+        System.out.println("Count : " + ex.countWaits());
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class CountdownLatchCountExampleUnitTest {
+
+    @Test
+    public void whenCountDownLatch_completed() {
+        CountdownLatchCountExample ex = new CountdownLatchCountExample(2);
+        boolean isCompleted = ex.callTwiceInSameThread();
+        assertTrue(isCompleted);
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class CountdownLatchResetExampleUnitTest {
+    
+    @Test
+    public void whenCountDownLatch_noReset() {
+        CountdownLatchResetExample ex = new CountdownLatchResetExample(7,20);
+        int lineCount = ex.countWaits();
+        assertTrue(lineCount <= 7);
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class CyclicBarrierCompletionMethodExampleUnitTest {
+    
+    @Test
+    public void whenCyclicBarrier_countTrips() {
+        CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(7,20);
+        int lineCount = ex.countTrips();
+        assertEquals(2, lineCount);
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+public class CyclicBarrierCountExampleUnitTest {
+
+    @Test
+    public void whenCyclicBarrier_notCompleted() {
+        CyclicBarrierCountExample ex = new CyclicBarrierCountExample(2);
+        boolean isCompleted = ex.callTwiceInSameThread();
+        assertFalse(isCompleted);
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class CyclicBarrierResetExampleUnitTest {
+    
+    @Test
+    public void whenCyclicBarrier_reset() {
+        CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7,20);
+        int lineCount = ex.countWaits();
+        assertTrue(lineCount > 7);
+    }
+}

core-java-lang/pom.xml

@@ -66,6 +66,12 @@
             <artifactId>mail</artifactId>
             <version>${javax.mail.version}</version>
         </dependency>
+        <dependency>
+            <groupId>nl.jqno.equalsverifier</groupId>
+            <artifactId>equalsverifier</artifactId>
+            <version>${equalsverifier.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -424,6 +430,7 @@
         <maven-shade-plugin.version>3.1.1</maven-shade-plugin.version>
         <spring-boot-maven-plugin.version>2.0.3.RELEASE</spring-boot-maven-plugin.version>
         <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
+        <equalsverifier.version>3.0.3</equalsverifier.version>
     </properties>
 
 </project>

core-java-lang/src/main/java/com/baeldung/equalshashcode/Money.java

@@ -0,0 +1,36 @@
+package com.baeldung.equalshashcode;
+
+class Money {
+
+    int amount;
+    String currencyCode;
+
+    Money(int amount, String currencyCode) {
+        this.amount = amount;
+        this.currencyCode = currencyCode;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Money))
+            return false;
+        Money other = (Money)o;
+        boolean currencyCodeEquals = (this.currencyCode == null && other.currencyCode == null)
+          || (this.currencyCode != null && this.currencyCode.equals(other.currencyCode));
+        return this.amount == other.amount
+          && currencyCodeEquals;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = 31 * result + amount;
+        if (currencyCode != null) {
+            result = 31 * result + currencyCode.hashCode();
+        }
+        return result;
+    }
+
+}

core-java-lang/src/main/java/com/baeldung/equalshashcode/Team.java

@@ -0,0 +1,39 @@
+package com.baeldung.equalshashcode;
+
+class Team {
+
+    final String city;
+    final String department;
+
+    Team(String city, String department) {
+        this.city = city;
+        this.department = department;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Team))
+            return false;
+        Team otherTeam = (Team)o;
+        boolean cityEquals = (this.city == null && otherTeam.city == null)
+          || this.city != null && this.city.equals(otherTeam.city);
+        boolean departmentEquals = (this.department == null && otherTeam.department == null)
+          || this.department != null && this.department.equals(otherTeam.department);
+        return cityEquals && departmentEquals;
+    }
+
+    @Override
+    public final int hashCode() {
+        int result = 17;
+        if (city != null) {
+            result = 31 * result + city.hashCode();
+        }
+        if (department != null) {
+            result = 31 * result + department.hashCode();
+        }
+        return result;
+    }
+
+}

core-java-lang/src/main/java/com/baeldung/equalshashcode/Voucher.java

@@ -0,0 +1,38 @@
+package com.baeldung.equalshashcode;
+
+class Voucher {
+
+    private Money value;
+    private String store;
+
+    Voucher(int amount, String currencyCode, String store) {
+        this.value = new Money(amount, currencyCode);
+        this.store = store;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Voucher))
+            return false;
+        Voucher other = (Voucher)o;
+        boolean valueEquals = (this.value == null && other.value == null)
+          || (this.value != null && this.value.equals(other.value));
+        boolean storeEquals = (this.store == null && other.store == null)
+          || (this.store != null && this.store.equals(other.store));
+        return valueEquals && storeEquals;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        if (this.value != null) {
+            result = 31 * result + value.hashCode();
+        }
+        if (this.store != null) {
+            result = 31 * result + store.hashCode();
+        }
+        return result;
+    }
+}

core-java-lang/src/main/java/com/baeldung/equalshashcode/WrongTeam.java

@@ -0,0 +1,30 @@
+package com.baeldung.equalshashcode;
+
+/* (non-Javadoc)
+* This class overrides equals, but it doesn't override hashCode.
+*
+* To see which problems this leads to:
+* TeamUnitTest.givenMapKeyWithoutHashCode_whenSearched_thenReturnsWrongValue
+*/
+class WrongTeam {
+
+    String city;
+    String department;
+
+    WrongTeam(String city, String department) {
+        this.city = city;
+        this.department = department;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof WrongTeam))
+            return false;
+        WrongTeam otherTeam = (WrongTeam)o;
+        return this.city == otherTeam.city
+          && this.department == otherTeam.department;
+    }
+
+}

core-java-lang/src/main/java/com/baeldung/equalshashcode/WrongVoucher.java

@@ -0,0 +1,47 @@
+package com.baeldung.equalshashcode;
+
+/* (non-Javadoc)
+* This class extends the Money class that has overridden the equals method and once again overrides the equals method.
+*
+* To see which problems this leads to:
+* MoneyUnitTest.givenMoneyAndVoucherInstances_whenEquals_thenReturnValuesArentSymmetric
+*/
+class WrongVoucher extends Money {
+
+    private String store;
+
+    WrongVoucher(int amount, String currencyCode, String store) {
+        super(amount, currencyCode);
+
+        this.store = store;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof WrongVoucher))
+            return false;
+        WrongVoucher other = (WrongVoucher)o;
+        boolean currencyCodeEquals = (this.currencyCode == null && other.currencyCode == null)
+          || (this.currencyCode != null && this.currencyCode.equals(other.currencyCode));
+        boolean storeEquals = (this.store == null && other.store == null)
+          || (this.store != null && this.store.equals(other.store));
+        return this.amount == other.amount
+          && currencyCodeEquals
+          && storeEquals;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = 31 * result + amount;
+        if (this.currencyCode != null) {
+            result = 31 * result + currencyCode.hashCode();
+        }
+        if (this.store != null) {
+            result = 31 * result + store.hashCode();
+        }
+        return result;
+    }
+}

core-java-lang/src/test/java/com/baeldung/equalshashcode/MoneyUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.equalshashcode;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+public class MoneyUnitTest {
+
+    @Test
+    public void givenMoneyInstancesWithSameAmountAndCurrency_whenEquals_thenReturnsTrue() {
+        Money income = new Money(55, "USD");
+        Money expenses = new Money(55, "USD");
+
+        assertTrue(income.equals(expenses));
+    }
+
+    @Test
+    public void givenMoneyAndVoucherInstances_whenEquals_thenReturnValuesArentSymmetric() {
+        Money cash = new Money(42, "USD");
+        WrongVoucher voucher = new WrongVoucher(42, "USD", "Amazon");
+
+        assertFalse(voucher.equals(cash));
+        assertTrue(cash.equals(voucher));
+    }
+
+}

core-java-lang/src/test/java/com/baeldung/equalshashcode/TeamUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.equalshashcode;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+
+public class TeamUnitTest {
+
+    @Test
+    public void givenMapKeyWithHashCode_whenSearched_thenReturnsCorrectValue() {
+        Map<Team,String> leaders = new HashMap<>();
+        leaders.put(new Team("New York", "development"), "Anne");
+        leaders.put(new Team("Boston", "development"), "Brian");
+        leaders.put(new Team("Boston", "marketing"), "Charlie");
+
+        Team myTeam = new Team("New York", "development");
+        String myTeamleader = leaders.get(myTeam);
+
+        assertEquals("Anne", myTeamleader);
+    }
+
+    @Test
+    public void givenMapKeyWithoutHashCode_whenSearched_thenReturnsWrongValue() {
+        Map<WrongTeam,String> leaders = new HashMap<>();
+        leaders.put(new WrongTeam("New York", "development"), "Anne");
+        leaders.put(new WrongTeam("Boston", "development"), "Brian");
+        leaders.put(new WrongTeam("Boston", "marketing"), "Charlie");
+
+        WrongTeam myTeam = new WrongTeam("New York", "development");
+        String myTeamleader = leaders.get(myTeam);
+
+        assertFalse("Anne".equals(myTeamleader));
+    }
+
+    @Test
+    public void equalsContract() {
+        EqualsVerifier.forClass(Team.class).verify();
+    }
+
+}

java-collections-conversions/src/test/java/org/baeldung/convertarraytostring/ArrayToStringUnitTest.java

@@ -0,0 +1,136 @@
+package org.baeldung.convertarraytostring;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class ArrayToStringUnitTest {
+    
+    // convert with Java
+    
+    @Test
+    public void givenAStringArray_whenConvertBeforeJava8_thenReturnString() {
+
+        String[] strArray = { "Convert", "Array", "With", "Java" };
+        StringBuilder stringBuilder = new StringBuilder();
+        
+        for (int i = 0; i < strArray.length; i++) {
+            stringBuilder.append(strArray[i]);
+        }
+        String joinedString = stringBuilder.toString();
+        
+        assertThat(joinedString, instanceOf(String.class));
+        assertEquals("ConvertArrayWithJava", joinedString);
+    }
+
+    @Test
+    public void givenAString_whenConvertBeforeJava8_thenReturnStringArray() {
+
+        String input = "lorem ipsum dolor sit amet";
+        String[] strArray = input.split(" ");
+
+        assertThat(strArray, instanceOf(String[].class));
+        assertEquals(5, strArray.length);
+        
+        input = "loremipsum";
+        strArray = input.split("");
+        assertThat(strArray, instanceOf(String[].class));
+        assertEquals(10, strArray.length);        
+    }    
+    
+    @Test
+    public void givenAnIntArray_whenConvertBeforeJava8_thenReturnString() {
+
+        int[] strArray = { 1, 2, 3, 4, 5 };
+        StringBuilder stringBuilder = new StringBuilder();
+        
+        for (int i = 0; i < strArray.length; i++) {
+            stringBuilder.append(Integer.valueOf(strArray[i]));
+        }
+        String joinedString = stringBuilder.toString();
+        
+        assertThat(joinedString, instanceOf(String.class));
+        assertEquals("12345", joinedString);
+    }    
+    
+    // convert with Java Stream API
+    
+    @Test
+    public void givenAStringArray_whenConvertWithJavaStream_thenReturnString() {
+
+        String[] strArray = { "Convert", "With", "Java", "Streams" };
+        String joinedString = Arrays.stream(strArray)
+            .collect(Collectors.joining());
+        assertThat(joinedString, instanceOf(String.class));
+        assertEquals("ConvertWithJavaStreams", joinedString);
+        
+        joinedString = Arrays.stream(strArray)
+            .collect(Collectors.joining(","));
+        assertThat(joinedString, instanceOf(String.class));
+        assertEquals("Convert,With,Java,Streams", joinedString);
+    }    
+    
+    
+    // convert with Apache Commons
+
+    @Test
+    public void givenAStringArray_whenConvertWithApacheCommons_thenReturnString() {
+
+        String[] strArray = { "Convert", "With", "Apache", "Commons" };
+        String joinedString = StringUtils.join(strArray);
+
+        assertThat(joinedString, instanceOf(String.class));
+        assertEquals("ConvertWithApacheCommons", joinedString);
+    }
+    
+    @Test
+    public void givenAString_whenConvertWithApacheCommons_thenReturnStringArray() {
+
+        String input = "lorem ipsum dolor sit amet";
+        String[] strArray = StringUtils.split(input, " ");
+        
+        assertThat(strArray, instanceOf(String[].class));
+        assertEquals(5, strArray.length);
+    }  
+
+    
+    // convert with Guava
+
+    @Test
+    public void givenAStringArray_whenConvertWithGuava_thenReturnString() {
+
+        String[] strArray = { "Convert", "With", "Guava", null };
+        String joinedString = Joiner.on("")
+            .skipNulls()
+            .join(strArray);
+
+        assertThat(joinedString, instanceOf(String.class));
+        assertEquals("ConvertWithGuava", joinedString);
+    }
+    
+    
+    @Test
+    public void givenAString_whenConvertWithGuava_thenReturnStringArray() {
+
+        String input = "lorem ipsum dolor sit amet";
+                        
+        List<String> resultList = Splitter.on(' ')
+            .trimResults()
+            .omitEmptyStrings()
+            .splitToList(input);   
+        String[] strArray = resultList.toArray(new String[0]);
+        
+        assertThat(strArray, instanceOf(String[].class));
+        assertEquals(5, strArray.length);    
+    }  
+}

java-strings/README.md

@@ -37,3 +37,4 @@
 - [Using indexOf to Find All Occurrences of a Word in a String](https://www.baeldung.com/java-indexOf-find-string-occurrences)
 - [Java Base64 Encoding and Decoding](https://www.baeldung.com/java-base64-encode-and-decode)
 - [Generate a Secure Random Password in Java](https://www.baeldung.com/java-generate-secure-password)
+- [Removing Repeated Characters from a String](https://www.baeldung.com/java-remove-repeated-char)

java-strings/src/test/java/com/baeldung/string/StringFromPrimitiveArrayUnitTest.java

@@ -0,0 +1,129 @@
+package com.baeldung.string;
+
+import com.google.common.base.Joiner;
+import com.google.common.primitives.Chars;
+import com.google.common.primitives.Ints;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import java.nio.CharBuffer;
+import java.util.Arrays;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class StringFromPrimitiveArrayUnitTest {
+
+    private int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    private char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
+
+    private char separatorChar = '-';
+
+    private String separator = String.valueOf(separatorChar);
+
+    private String expectedIntString = "1-2-3-4-5-6-7-8-9";
+
+    private String expectedCharString = "a-b-c-d-e-f";
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_Java8CollectorsJoining() {
+        assertThat(Arrays.stream(intArray)
+          .mapToObj(String::valueOf)
+          .collect(Collectors.joining(separator)))
+          .isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_Java8CollectorsJoining() {
+        assertThat(CharBuffer.wrap(charArray).chars()
+          .mapToObj(intChar -> String.valueOf((char) intChar))
+          .collect(Collectors.joining(separator)))
+          .isEqualTo(expectedCharString);
+    }
+
+
+    @Test
+    public void giveIntArray_whenJoinBySeparator_thenReturnsString_through_Java8StringJoiner() {
+        StringJoiner intStringJoiner = new StringJoiner(separator);
+
+        Arrays.stream(intArray)
+          .mapToObj(String::valueOf)
+          .forEach(intStringJoiner::add);
+
+        assertThat(intStringJoiner.toString()).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_Java8StringJoiner() {
+        StringJoiner charStringJoiner = new StringJoiner(separator);
+
+        CharBuffer.wrap(charArray).chars()
+          .mapToObj(intChar -> String.valueOf((char) intChar))
+          .forEach(charStringJoiner::add);
+
+        assertThat(charStringJoiner.toString()).isEqualTo(expectedCharString);
+    }
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_CommonsLang() {
+        assertThat(StringUtils.join(intArray, separatorChar)).isEqualTo(expectedIntString);
+        assertThat(StringUtils.join(ArrayUtils.toObject(intArray), separator)).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_CommonsLang() {
+        assertThat(StringUtils.join(charArray, separatorChar)).isEqualTo(expectedCharString);
+        assertThat(StringUtils.join(ArrayUtils.toObject(charArray), separator)).isEqualTo(expectedCharString);
+    }
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_GuavaJoiner() {
+        assertThat(Joiner.on(separator).join(Ints.asList(intArray))).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_GuavaJoiner() {
+        assertThat(Joiner.on(separator).join(Chars.asList(charArray))).isEqualTo(expectedCharString);
+    }
+
+    @Test
+    public void givenIntArray_whenJoinBySeparator_thenReturnsString_through_Java7StringBuilder() {
+        assertThat(joinIntArrayWithStringBuilder(intArray, separator)).isEqualTo(expectedIntString);
+    }
+
+    @Test
+    public void givenCharArray_whenJoinBySeparator_thenReturnsString_through_Java7StringBuilder() {
+        assertThat(joinCharArrayWithStringBuilder(charArray, separator)).isEqualTo(expectedCharString);
+    }
+
+    private String joinIntArrayWithStringBuilder(int[] array, String separator) {
+        if (array.length == 0) {
+            return "";
+        }
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < array.length - 1; i++) {
+            stringBuilder.append(array[i]);
+            stringBuilder.append(separator);
+        }
+        stringBuilder.append(array[array.length - 1]);
+        return stringBuilder.toString();
+    }
+
+    private String joinCharArrayWithStringBuilder(char[] array, String separator) {
+        if (array.length == 0) {
+            return "";
+        }
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < array.length - 1; i++) {
+            stringBuilder.append(array[i]);
+            stringBuilder.append(separator);
+        }
+        stringBuilder.append(array[array.length - 1]);
+        return stringBuilder.toString();
+    }
+
+}

persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/findall/FindAll.java

@@ -0,0 +1,35 @@
+package com.baeldung.hibernate.findall;
+
+import java.util.List;
+
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+import org.hibernate.Session;
+
+import com.baeldung.hibernate.pojo.Student;
+
+public class FindAll {
+
+    private Session session;
+
+    public FindAll(Session session) {
+        super();
+        this.session = session;
+    }
+
+    public List<Student> findAllWithJpql() {
+        return session.createQuery("SELECT a FROM Student a", Student.class).getResultList();
+    }
+
+    public List<Student> findAllWithCriteriaQuery() {
+        CriteriaBuilder cb = session.getCriteriaBuilder();
+        CriteriaQuery<Student> cq = cb.createQuery(Student.class);
+        Root<Student> rootEntry = cq.from(Student.class);
+        CriteriaQuery<Student> all = cq.select(rootEntry);
+        TypedQuery<Student> allQuery = session.createQuery(all);
+        return allQuery.getResultList();
+    }
+}

persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/findall/FindAllUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.hibernate.findall;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.pojo.Student;
+
+public class FindAllUnitTest {
+
+    private Session session;
+    private Transaction transaction;
+    
+    private FindAll findAll;
+
+    @Before
+    public void setUp() throws IOException {
+
+        session = HibernateUtil.getSessionFactory().openSession();
+        transaction = session.beginTransaction();
+        findAll = new FindAll(session);
+
+        session.createNativeQuery("delete from Student").executeUpdate();
+
+        Student student1 = new Student();
+        session.persist(student1);
+
+        Student student2 = new Student();
+        session.persist(student2);
+
+        Student student3 = new Student();
+        session.persist(student3);
+
+        transaction.commit();
+        transaction = session.beginTransaction();
+    }
+
+    @After
+    public void tearDown() {
+        transaction.rollback();
+        session.close();
+    }
+
+    @Test
+    public void givenCriteriaQuery_WhenFindAll_ThenGetAllPersons() {
+        List<Student> list = findAll.findAllWithCriteriaQuery();
+        assertEquals(3, list.size());
+    }
+    
+    @Test
+    public void givenJpql_WhenFindAll_ThenGetAllPersons() {
+        List<Student> list = findAll.findAllWithJpql();
+        assertEquals(3, list.size());
+    }
+}

persistence-modules/spring-data-jpa/src/main/java/com/baeldung/limit/PassengerRepository.java

@@ -1,8 +0,0 @@
-package com.baeldung.limit;
-
-import org.springframework.data.jpa.repository.JpaRepository;
-
-interface PassengerRepository extends JpaRepository<Passenger, Long>, CustomPassengerRepository {
-
-    Passenger findFirstByOrderBySeatNumberAsc();
-}

persistence-modules/spring-data-jpa/src/main/java/com/baeldung/passenger/CustomPassengerRepository.java

@@ -1,4 +1,4 @@
-package com.baeldung.limit;
+package com.baeldung.passenger;
 
 import java.util.List;
 

persistence-modules/spring-data-jpa/src/main/java/com/baeldung/passenger/Passenger.java

@@ -1,4 +1,4 @@
-package com.baeldung.limit;
+package com.baeldung.passenger;
 
 import javax.persistence.Basic;
 import javax.persistence.Column;
@@ -17,7 +17,7 @@ class Passenger {
 
     @Basic(optional = false)
     @Column(nullable = false)
-    private String fistName;
+    private String firstName;
 
     @Basic(optional = false)
     @Column(nullable = false)
@@ -27,8 +27,8 @@ class Passenger {
     @Column(nullable = false)
     private int seatNumber;
 
-    private Passenger(String fistName, String lastName, int seatNumber) {
-        this.fistName = fistName;
+    private Passenger(String firstName, String lastName, int seatNumber) {
+        this.firstName = firstName;
         this.lastName = lastName;
         this.seatNumber = seatNumber;
     }
@@ -44,20 +44,20 @@ class Passenger {
         if (object == null || getClass() != object.getClass())
             return false;
         Passenger passenger = (Passenger) object;
-        return getSeatNumber() == passenger.getSeatNumber() && Objects.equals(getFistName(), passenger.getFistName())
+        return getSeatNumber() == passenger.getSeatNumber() && Objects.equals(getFirstName(), passenger.getFirstName())
           && Objects.equals(getLastName(), passenger.getLastName());
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(getFistName(), getLastName(), getSeatNumber());
+        return Objects.hash(getFirstName(), getLastName(), getSeatNumber());
     }
 
     @Override
     public String toString() {
         final StringBuilder toStringBuilder = new StringBuilder(getClass().getSimpleName());
         toStringBuilder.append("{ id=").append(id);
-        toStringBuilder.append(", fistName='").append(fistName).append('\'');
+        toStringBuilder.append(", firstName='").append(firstName).append('\'');
         toStringBuilder.append(", lastName='").append(lastName).append('\'');
         toStringBuilder.append(", seatNumber=").append(seatNumber);
         toStringBuilder.append('}');
@@ -68,8 +68,8 @@ class Passenger {
         return id;
     }
 
-    String getFistName() {
-        return fistName;
+    String getFirstName() {
+        return firstName;
     }
 
     String getLastName() {

persistence-modules/spring-data-jpa/src/main/java/com/baeldung/passenger/PassengerRepository.java

@@ -0,0 +1,17 @@
+package com.baeldung.passenger;
+
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+interface PassengerRepository extends JpaRepository<Passenger, Long>, CustomPassengerRepository {
+
+    Passenger findFirstByOrderBySeatNumberAsc();
+
+    List<Passenger> findByOrderBySeatNumberAsc();
+    
+    List<Passenger> findByLastNameOrderBySeatNumberAsc(String lastName);
+    
+    List<Passenger> findByLastName(String lastName, Sort sort);
+}

persistence-modules/spring-data-jpa/src/main/java/com/baeldung/passenger/PassengerRepositoryImpl.java

@@ -1,4 +1,4 @@
-package com.baeldung.limit;
+package com.baeldung.passenger;
 
 import org.springframework.stereotype.Repository;
 

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/passenger/PassengerRepositoryIntegrationTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.limit;
+package com.baeldung.passenger;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -14,11 +14,13 @@ import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import java.util.List;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
 import static org.junit.Assert.assertEquals;
 
 @DataJpaTest
 @RunWith(SpringRunner.class)
-public class LimitIntegrationTest {
+public class PassengerRepositoryIntegrationTest {
 
     @PersistenceContext
     private EntityManager entityManager;
@@ -66,4 +68,31 @@ public class LimitIntegrationTest {
         Passenger actual = page.getContent().get(0);
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void givenPassengers_whenOrderedBySeatNumberAsc_thenCorrectOrder() {
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+
+        List<Passenger> passengers = repository.findByOrderBySeatNumberAsc();
+
+        assertThat(passengers, contains(fred, ricki, jill, siya, eve));
+    }
+
+    @Test
+    public void givenPassengers_whenFindAllWithSortBySeatNumberAsc_thenCorrectOrder() {
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+
+        List<Passenger> passengers = repository.findAll(Sort.by(Sort.Direction.ASC, "seatNumber"));
+
+        assertThat(passengers, contains(fred, ricki, jill, siya, eve));
+    }
+    
 }

spring-5-reactive/src/main/java/com/baeldung/debugging/consumer/ConsumerSSEApplication.java

@@ -0,0 +1,33 @@
+package com.baeldung.debugging.consumer;
+
+import java.util.Collections;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+import reactor.core.publisher.Hooks;
+
+@SpringBootApplication(exclude = MongoReactiveAutoConfiguration.class)
+@EnableScheduling
+public class ConsumerSSEApplication {
+
+    public static void main(String[] args) {
+        Hooks.onOperatorDebug();
+        SpringApplication app = new SpringApplication(ConsumerSSEApplication.class);
+        app.setDefaultProperties(Collections.singletonMap("server.port", "8082"));
+        app.run(args);
+    }
+
+    @Bean
+    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .permitAll();
+        return http.build();
+    }
+}