@@ -0,0 +1,57 @@
+package com.hellokoding.java.collections;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class ArrayListIterateTest {
+    @Test
+    public void forIndex() {
+        List<Integer> lst = new ArrayList<>();
+        lst.add(1);
+        lst.add(2);
+        lst.add(3);
+
+        for(int i=0; i<lst.size(); i++){
+            int ele = lst.get(i);
+            System.out.println(ele);
+        }
+    }
+
+    @Test
+    public void forEach() {
+        List<Integer> lst = new ArrayList<>();
+        lst.add(1);
+        lst.add(2);
+        lst.add(3);
+
+        for(int ele : lst){
+            System.out.println(ele);
+        }
+    }
+
+    @Test
+    public void forEachConsumer() {
+        List<Integer> lst = new ArrayList<>();
+        lst.add(1);
+        lst.add(2);
+        lst.add(3);
+
+        lst.forEach(System.out::println);
+    }
+
+    @Test
+    public void iterator() {
+        List<Integer> lst = new ArrayList<>();
+        lst.add(1);
+        lst.add(2);
+        lst.add(3);
+
+        Iterator<Integer> iterator = lst.iterator();
+        while (iterator.hasNext()){
+            System.out.println(iterator.next());
+        }
+    }
+}
@@ -0,0 +1,44 @@
+package com.hellokoding.java.collections;
+
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ArrayListOverviewTest {
+    @Test
+    public void declare() {
+        List<Integer> lst1 = new ArrayList<>();
+        assertThat(lst1).isInstanceOf(ArrayList.class);
+
+        Collection<Integer> lst2 = new ArrayList<>();
+        assertThat(lst2).isInstanceOf(ArrayList.class);
+
+        Iterable<Integer> lst3 = new ArrayList<>();
+        assertThat(lst3).isInstanceOf(ArrayList.class);
+
+        ArrayList<Integer> lst4 = new ArrayList<>();
+    }
+
+    @Test
+    public void initialize() {
+        // Create a new ArrayList
+        List<Integer> lst = new ArrayList<>();
+
+        // Add elements to ArrayList
+        lst.add(3);
+        lst.add(1);
+        lst.add(2);
+
+        // Can add null element
+        lst.add(null);
+
+        // Can add duplicate element
+        lst.add(2);
+        assertThat(lst).hasSize(5);
+
+        // The output ordering will be same as the insertion oder
+        System.out.println(lst);
+    }
+}
@@ -20,7 +20,7 @@ public void filter() {
     }
 
     @Test
-    public void get_OK() {
+    public void get_thenOK() {
         List<Integer> lst = new ArrayList<>();
         lst.add(3);
         lst.add(1);
@@ -31,7 +31,7 @@ public void get_OK() {
     }
 
     @Test(expected = IndexOutOfBoundsException.class)
-    public void get_Exception() {
+    public void get_thenException() {
         List<Integer> lst = new ArrayList<>();
         lst.add(3);
         lst.add(1);
 
@@ -0,0 +1,68 @@
+package com.hellokoding.java.concurrent;
+
+import org.junit.Test;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ForkJoinPool;
+
+import static com.hellokoding.java.concurrent.ConcurrentUtils.stop;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SynchronizedTest {
+    private ExecutorService executorService = Executors.newFixedThreadPool(3);
+
+    @Test
+    public void runAsync() {
+        Counter counter = new Counter();
+
+        for (int i = 0; i < 10000; i++) {
+            CompletableFuture.runAsync(counter::increaseRunnable);
+        }
+
+        stop(ForkJoinPool.commonPool());
+
+        assertThat(counter.count).isEqualTo(10000);
+    }
+
+    @Test
+    public void runAsyncWithExecutorService() {
+        Counter counter = new Counter();
+
+        for (int i = 0; i < 10000; i++) {
+            CompletableFuture.runAsync(counter::increaseRunnable, executorService);
+        }
+
+        stop(executorService);
+
+        assertThat(counter.count).isEqualTo(10000);
+    }
+
+    @Test
+    public void supplyAsync() {
+        Counter counter = new Counter();
+
+        for (int i = 0; i < 10000; i++) {
+            CompletableFuture.supplyAsync(counter::increaseSupplier, executorService);
+        }
+
+        stop(executorService);
+
+        assertThat(counter.count).isEqualTo(10000);
+    }
+
+    class Counter {
+        int count = 0;
+
+        synchronized void increaseRunnable() {
+            count++;
+        }
+
+        synchronized int increaseSupplier() {
+            count++;
+
+            return count;
+        }
+    }
+}