Merge remote-tracking branch 'eugenp/master'

Author: Doha2012

.travis.yml

@@ -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
 

core-java/src/main/java/com/baeldung/heapsort/Heap.java renamed to algorithms/src/main/java/com/baeldung/algorithms/heapsort/Heap.java

@@ -1,4 +1,4 @@
-package com.baeldung.heapsort;
+package com.baeldung.algorithms.heapsort;
 
 import java.util.ArrayList;
 import java.util.Arrays;

core-java/src/test/java/com/baeldung/heapsort/HeapUnitTest.java renamed to algorithms/src/test/java/com/baeldung/algorithms/heapsort/HeapUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.heapsort;
+package com.baeldung.algorithms.heapsort;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

core-java-8/README.md

@@ -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)

core-java-8/findItemsBasedOnValues/.gitignore

@@ -55,3 +55,4 @@
 - [Sort a HashMap in Java](https://www.baeldung.com/java-hashmap-sort)
 - [Finding the Highest Value in a Java Map](https://www.baeldung.com/java-find-map-max)
 - [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)

core-java-collections/README.md

@@ -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));
+    }
+}

core-java-collections/src/main/java/com/baeldung/removal/CollectionRemoveIf.java

@@ -0,0 +1,28 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+public class Iterators {
+
+    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");
+
+        Iterator<String> i = names.iterator();
+
+        while (i.hasNext()) {
+            String e = i.next();
+            if (e.startsWith("A")) {
+                i.remove();
+            }
+        }
+
+        System.out.println(String.join(",", names));
+    }
+}

core-java-collections/src/main/java/com/baeldung/removal/Iterators.java

@@ -0,0 +1,23 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public class StreamFilterAndCollector {
+
+    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");
+
+        Collection<String> filteredCollection = names
+                .stream()
+                .filter(e -> !e.startsWith("A"))
+                .collect(Collectors.toList());
+        System.out.println(String.join(",", filteredCollection));
+    }
+}

core-java-collections/src/main/java/com/baeldung/removal/StreamFilterAndCollector.java

@@ -0,0 +1,28 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class StreamPartitioningBy {
+
+    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");
+
+        Map<Boolean, List<String>> classifiedElements = names
+                .stream()
+                .collect(Collectors.partitioningBy((String e) -> !e.startsWith("A")));
+
+        String matching = String.join(",", classifiedElements.get(Boolean.TRUE));
+        String nonMatching = String.join(",", classifiedElements.get(Boolean.FALSE));
+        System.out.println("Matching elements: " + matching);
+        System.out.println("Non matching elements: " + nonMatching);
+    }
+}

core-java-collections/src/main/java/com/baeldung/removal/StreamPartitioningBy.java

@@ -1,93 +1,89 @@
-package findItems;
-
-import static org.junit.Assert.assertEquals;
-
-import java.text.ParseException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.junit.Test;
-
-public class FindItemsBasedOnValues {
-
-    List<Employee> EmplList = new ArrayList<Employee>();
-    List<Department> deptList = new ArrayList<Department>();
-
-    public static void main(String[] args) throws ParseException {
-        FindItemsBasedOnValues findItems = new FindItemsBasedOnValues();
-        findItems.givenDepartmentList_thenEmployeeListIsFilteredCorrectly();
-    }
-
-    @Test
-    public void givenDepartmentList_thenEmployeeListIsFilteredCorrectly() {
-        Integer expectedId = 1002;
-
-        populate(EmplList, deptList);
-
-        List<Employee> filteredList = EmplList.stream()
-            .filter(empl -> deptList.stream()
-                .anyMatch(dept -> dept.getDepartment()
-                    .equals("sales") && empl.getEmployeeId()
-                    .equals(dept.getEmployeeId())))
-            .collect(Collectors.toList());
-
-        assertEquals(expectedId, filteredList.get(0)
-            .getEmployeeId());
-    }
-
-    private void populate(List<Employee> EmplList, List<Department> deptList) {
-        Employee employee1 = new Employee(1001, "empl1");
-        Employee employee2 = new Employee(1002, "empl2");
-        Employee employee3 = new Employee(1003, "empl3");
-
-        Collections.addAll(EmplList, employee1, employee2, employee3);
-
-        Department department1 = new Department(1002, "sales");
-        Department department2 = new Department(1003, "marketing");
-        Department department3 = new Department(1004, "sales");
-
-        Collections.addAll(deptList, department1, department2, department3);
-    }
-}
-
-class Employee {
-    Integer employeeId;
-    String employeeName;
-
-    public Employee(Integer employeeId, String employeeName) {
-        super();
-        this.employeeId = employeeId;
-        this.employeeName = employeeName;
-    }
-
-    public Integer getEmployeeId() {
-        return employeeId;
-    }
-
-    public String getEmployeeName() {
-        return employeeName;
-    }
-
-}
-
-class Department {
-    Integer employeeId;
-    String department;
-
-    public Department(Integer employeeId, String department) {
-        super();
-        this.employeeId = employeeId;
-        this.department = department;
-    }
-
-    public Integer getEmployeeId() {
-        return employeeId;
-    }
-
-    public String getDepartment() {
-        return department;
-    }
-
+package com.baeldung.findItems;
+
+import static org.junit.Assert.assertEquals;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+
+public class FindItemsBasedOnOtherStreamUnitTest {
+
+    private List<Employee> employeeList = new ArrayList<Employee>();
+
+    private List<Department> departmentList = new ArrayList<Department>();
+
+    @Test
+    public void givenDepartmentList_thenEmployeeListIsFilteredCorrectly() {
+        Integer expectedId = 1002;
+
+        populate(employeeList, departmentList);
+
+        List<Employee> filteredList = employeeList.stream()
+            .filter(empl -> departmentList.stream()
+                .anyMatch(dept -> dept.getDepartment()
+                    .equals("sales") && empl.getEmployeeId()
+                    .equals(dept.getEmployeeId())))
+            .collect(Collectors.toList());
+
+        assertEquals(expectedId, filteredList.get(0)
+            .getEmployeeId());
+    }
+
+    private void populate(List<Employee> EmplList, List<Department> deptList) {
+        Employee employee1 = new Employee(1001, "empl1");
+        Employee employee2 = new Employee(1002, "empl2");
+        Employee employee3 = new Employee(1003, "empl3");
+
+        Collections.addAll(EmplList, employee1, employee2, employee3);
+
+        Department department1 = new Department(1002, "sales");
+        Department department2 = new Department(1003, "marketing");
+        Department department3 = new Department(1004, "sales");
+
+        Collections.addAll(deptList, department1, department2, department3);
+    }
+}
+
+class Employee {
+    private Integer employeeId;
+    private String employeeName;
+
+    Employee(Integer employeeId, String employeeName) {
+        super();
+        this.employeeId = employeeId;
+        this.employeeName = employeeName;
+    }
+
+    Integer getEmployeeId() {
+        return employeeId;
+    }
+
+    public String getEmployeeName() {
+        return employeeName;
+    }
+
+}
+
+class Department {
+    private Integer employeeId;
+    private String department;
+
+    Department(Integer employeeId, String department) {
+        super();
+        this.employeeId = employeeId;
+        this.department = department;
+    }
+
+    Integer getEmployeeId() {
+        return employeeId;
+    }
+
+    String getDepartment() {
+        return department;
+    }
+
 }

core-java-8/findItemsBasedOnValues/src/findItems/FindItemsBasedOnValues.java renamed to core-java-collections/src/test/java/com/baeldung/findItems/FindItemsBasedOnOtherStreamUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.removal;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class RemovalUnitTest {
+
+    Collection<String> names;
+    Collection<String> expected;
+    Collection<String> removed;
+
+    @Before
+    public void setupTestData() {
+        names = new ArrayList<>();
+        expected = new ArrayList<>();
+        removed = new ArrayList<>();
+
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        expected.add("John");
+        expected.add("Mary");
+        expected.add("Mark");
+
+        removed.add("Ana");
+        removed.add("Anthony");
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingIteratorToRemoveAllNamesStartingWithLetterA_finalListShouldContainNoNamesStartingWithLetterA() {
+        Iterator<String> i = names.iterator();
+
+        while (i.hasNext()) {
+            String e = i.next();
+            if (e.startsWith("A")) {
+                i.remove();
+            }
+        }
+
+        assertThat(names, is(expected));
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingRemoveIfToRemoveAllNamesStartingWithLetterA_finalListShouldContainNoNamesStartingWithLetterA() {
+        names.removeIf(e -> e.startsWith("A"));
+        assertThat(names, is(expected));
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingStreamToFilterAllNamesStartingWithLetterA_finalListShouldContainNoNamesStartingWithLetterA() {
+        Collection<String> filteredCollection = names
+                .stream()
+                .filter(e -> !e.startsWith("A"))
+                .collect(Collectors.toList());
+        assertThat(filteredCollection, is(expected));
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingStreamAndPartitioningByToFindNamesThatStartWithLetterA_shouldFind3MatchingAnd2NonMatching() {
+        Map<Boolean, List<String>> classifiedElements = names
+                .stream()
+                .collect(Collectors.partitioningBy((String e) -> !e.startsWith("A")));
+
+        assertThat(classifiedElements.get(Boolean.TRUE), is(expected));
+        assertThat(classifiedElements.get(Boolean.FALSE), is(removed));
+    }
+
+}