Merge remote-tracking branch 'upstream/master'

2018-11-29 20:51:40 -06:00
parent 1f8c4560a2 97fe04aace
commit 136a66a7b5
100 changed files with 3412 additions and 41 deletions
@@ -0,0 +1,67 @@
+package com.baeldung.java.list;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+/**
+ *  Demonstrates the different ways to loop over
+ *  the elements of a list.
+ */
+public class WaysToIterate {
+
+    List<String> countries = Arrays.asList("Germany", "Panama", "Australia");
+
+    /**
+     * Iterate over a list using a basic for loop
+     */
+    public void iterateWithForLoop() {
+        for (int i = 0; i < countries.size(); i++) {
+            System.out.println(countries.get(i));
+        }
+    }
+
+    /**
+     * Iterate over a list using the enhanced for loop
+     */
+    public void iterateWithEnhancedForLoop() {
+        for (String country : countries) {
+            System.out.println(country);
+        }
+    }
+
+    /**
+     * Iterate over a list using an Iterator
+     */
+    public void iterateWithIterator() {
+        Iterator<String> countriesIterator = countries.iterator();
+        while(countriesIterator.hasNext()) {
+            System.out.println(countriesIterator.next());
+        }
+    }
+
+    /**
+     * Iterate over a list using a ListIterator
+     */
+    public void iterateWithListIterator() {
+        ListIterator<String> listIterator = countries.listIterator();
+        while(listIterator.hasNext()) {
+            System.out.println(listIterator.next());
+        }
+    }
+
+    /**
+     * Iterate over a list using the Iterable.forEach() method
+     */
+    public void iterateWithForEach() {
+        countries.forEach(System.out::println);
+    }
+
+    /**
+     * Iterate over a list using the Stream.forEach() method
+     */
+    public void iterateWithStreamForEach() {
+        countries.stream().forEach((c) -> System.out.println(c));
+    }
+}
@@ -0,0 +1,71 @@
+package com.baeldung.java.list;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+import org.junit.Test;
+
+public class WaysToIterateUnitTest {
+
+    List<String> globalCountries = new ArrayList<String>();
+    List<String> europeanCountries = Arrays.asList("Germany", "Panama", "Australia");
+
+    @Test
+    public void whenIteratingUsingForLoop_thenReturnThreeAsSizeOfList() {
+        for (int i = 0; i < europeanCountries.size(); i++) {
+            globalCountries.add(europeanCountries.get(i));
+        }
+        assertEquals(globalCountries.size(), 3);
+        globalCountries.clear();
+    }
+
+    @Test
+    public void whenIteratingUsingEnhancedForLoop_thenReturnThreeAsSizeOfList() {
+        for (String country : europeanCountries) {
+            globalCountries.add(country);
+        }
+        assertEquals(globalCountries.size(), 3);
+        globalCountries.clear();
+    }
+
+    @Test
+    public void whenIteratingUsingIterator_thenReturnThreeAsSizeOfList() {
+        Iterator<String> countriesIterator = europeanCountries.iterator();
+        while (countriesIterator.hasNext()) {
+            globalCountries.add(countriesIterator.next());
+        }
+
+        assertEquals(globalCountries.size(), 3);
+        globalCountries.clear();
+    }
+
+    @Test
+    public void whenIteratingUsingListIterator_thenReturnThreeAsSizeOfList() {
+        ListIterator<String> countriesIterator = europeanCountries.listIterator();
+        while (countriesIterator.hasNext()) {
+            globalCountries.add(countriesIterator.next());
+        }
+
+        assertEquals(globalCountries.size(), 3);
+        globalCountries.clear();
+    }
+
+    @Test
+    public void whenIteratingUsingForEach_thenReturnThreeAsSizeOfList() {
+        europeanCountries.forEach(country -> globalCountries.add(country));
+        assertEquals(globalCountries.size(), 3);
+        globalCountries.clear();
+    }
+
+    @Test
+    public void whenIteratingUsingStreamForEach_thenReturnThreeAsSizeOfList() {
+        europeanCountries.stream().forEach((country) -> globalCountries.add(country));
+        assertEquals(globalCountries.size(), 3);
+        globalCountries.clear();
+    }
+}
@@ -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());
+    }
+}
@@ -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());
+    }
+}
@@ -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());
+    }
+}
@@ -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());
+    }
+}
@@ -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());
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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>
@@ -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;
+    }
+
+}
@@ -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;
+    }
+
+}
@@ -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;
+    }
+}
@@ -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;
+    }
+
+}
@@ -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;
+    }
+}
@@ -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));
+    }
+
+}
@@ -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();
+    }
+
+}
@@ -0,0 +1,76 @@
+package com.baeldung.graph;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Graph {
+    private Map<Vertex, List<Vertex>> adjVertices;
+
+    Graph() {
+        this.adjVertices = new HashMap<Vertex, List<Vertex>>();
+    }
+
+    void addVertex(String label) {
+        adjVertices.putIfAbsent(new Vertex(label), new ArrayList<>());
+    }
+
+    void removeVertex(String label) {
+        Vertex v = new Vertex(label);
+        adjVertices.values().stream().map(e -> e.remove(v)).collect(Collectors.toList());
+        adjVertices.remove(new Vertex(label));
+    }
+
+    void addEdge(String label1, String label2) {
+        Vertex v1 = new Vertex(label1);
+        Vertex v2 = new Vertex(label2);
+        adjVertices.get(v1).add(v2);
+        adjVertices.get(v2).add(v1);
+    }
+
+    void removeEdge(String label1, String label2) {
+        Vertex v1 = new Vertex(label1);
+        Vertex v2 = new Vertex(label2);
+        List<Vertex> eV1 = adjVertices.get(v1);
+        List<Vertex> eV2 = adjVertices.get(v2);
+        if (eV1 != null)
+            eV1.remove(v2);
+        if (eV2 != null)
+            eV2.remove(v1);
+    }
+
+    List<Vertex> getAdjVertices(String label) {
+        return adjVertices.get(new Vertex(label));
+    }
+    
+    String printGraph() {
+        StringBuffer sb = new StringBuffer();
+        for(Vertex v : adjVertices.keySet()) {
+            sb.append(v);
+            sb.append(adjVertices.get(v));
+        }
+        return sb.toString();
+    }
+
+    class Vertex {
+        String label;
+        Vertex(String label) {
+            this.label = label;
+        }
+        @Override
+        public boolean equals(Object obj) {
+            Vertex vertex = (Vertex) obj;
+            return vertex.label == label;
+        }
+        @Override
+        public int hashCode() {
+            return label.hashCode();
+        }
+        @Override
+        public String toString() {
+            return label;
+        }
+    }
+}
@@ -0,0 +1,44 @@
+package com.baeldung.graph;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+import java.util.Stack;
+
+import com.baeldung.graph.Graph.Vertex;
+
+public class GraphTraversal {
+    static Set<String> depthFirstTraversal(Graph graph, String root) {
+        Set<String> visited = new LinkedHashSet<String>();
+        Stack<String> stack = new Stack<String>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            String vertex = stack.pop();
+            if (!visited.contains(vertex)) {
+                visited.add(vertex);
+                for (Vertex v : graph.getAdjVertices(vertex)) {              
+                    stack.push(v.label);
+                }
+            }
+        }
+        return visited;
+    }
+
+    static Set<String> breadthFirstTraversal(Graph graph, String root) {
+        Set<String> visited = new LinkedHashSet<String>();
+        Queue<String> queue = new LinkedList<String>();
+        queue.add(root);
+        visited.add(root);
+        while (!queue.isEmpty()) {
+            String vertex = queue.poll();
+            for (Vertex v : graph.getAdjVertices(vertex)) {
+                if (!visited.contains(v.label)) {
+                    visited.add(v.label);
+                    queue.add(v.label);
+                }
+            }
+        }
+        return visited;
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.graph;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class GraphTraversalUnitTest {
+    @Test
+    public void givenAGraph_whenTraversingDepthFirst_thenExpectedResult() {
+        Graph graph = createGraph();
+        Assert.assertEquals("[Bob, Rob, Maria, Alice, Mark]", 
+            GraphTraversal.depthFirstTraversal(graph, "Bob").toString());
+    }
+    
+    @Test
+    public void givenAGraph_whenTraversingBreadthFirst_thenExpectedResult() {
+        Graph graph = createGraph();
+        Assert.assertEquals("[Bob, Alice, Rob, Mark, Maria]", 
+            GraphTraversal.breadthFirstTraversal(graph, "Bob").toString());
+    }
+    
+    Graph createGraph() {
+        Graph graph = new Graph();
+        graph.addVertex("Bob");
+        graph.addVertex("Alice");
+        graph.addVertex("Mark");
+        graph.addVertex("Rob");
+        graph.addVertex("Maria");
+        graph.addEdge("Bob", "Alice");
+        graph.addEdge("Bob", "Rob");
+        graph.addEdge("Alice", "Mark");
+        graph.addEdge("Rob", "Mark");
+        graph.addEdge("Alice", "Maria");
+        graph.addEdge("Rob", "Maria");
+        return graph;
+    }
+}
@@ -11,7 +11,7 @@ import java.util.regex.Pattern;

 import static org.junit.Assert.assertTrue;

-public class OptimizedMatcherUnitTest {
+public class OptimizedMatcherManualTest {

    private String action;

@@ -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);    
+    }  
+}
@@ -0,0 +1,20 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name=local-file-sink
+connector.class=FileStreamSink
+tasks.max=1
+file=test.sink.txt
+topics=connect-test
@@ -0,0 +1,20 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name=local-file-source
+connector.class=FileStreamSource
+tasks.max=1
+file=test.txt
+topic=connect-test
@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# These are defaults. This file just demonstrates how to override some settings.
+bootstrap.servers=localhost:9092
+
+# The converters specify the format of data in Kafka and how to translate it into Connect data. Every Connect user will
+# need to configure these based on the format they want their data in when loaded from or stored into Kafka
+key.converter=org.apache.kafka.connect.json.JsonConverter
+value.converter=org.apache.kafka.connect.json.JsonConverter
+# Converter-specific settings can be passed in by prefixing the Converter's setting with the converter we want to apply
+# it to
+key.converter.schemas.enable=false
+value.converter.schemas.enable=false
+
+offset.storage.file.filename=/tmp/connect.offsets
+# Flush much faster than normal, which is useful for testing/debugging
+offset.flush.interval.ms=10000
+
+# Set to a list of filesystem paths separated by commas (,) to enable class loading isolation for plugins
+# (connectors, converters, transformations). The list should consist of top level directories that include 
+# any combination of: 
+# a) directories immediately containing jars with plugins and their dependencies
+# b) uber-jars with plugins and their dependencies
+# c) directories immediately containing the package directory structure of classes of plugins and their dependencies
+# Note: symlinks will be followed to discover dependencies or plugins.
+# Examples: 
+# plugin.path=/usr/local/share/java,/usr/local/share/kafka/plugins,/opt/connectors,
+# Replace the relative path below with an absolute path if you are planning to start Kafka Connect from within a
+# directory other than the home directory of Confluent Platform.
+plugin.path=C:\Software\confluent-5.0.0\share\java
+#plugin.path=./share/java
--- a/Show More
+++ b/Show More