From 2bd55bb19522e26868ff5cdad329b178c5b59a94 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Mon, 1 Apr 2019 19:32:50 +0300 Subject: [PATCH 01/11] BAEL-2800_Copying_a_HashMap_in_Java --- .../baeldung/copyinghashmap/CopyHashMap.java | 46 ++++++++ .../copyinghashmap/CopyHashMapUnitTest.java | 100 ++++++++++++++++++ .../com/baeldung/copyinghashmap/Employee.java | 38 +++++++ 3 files changed, 184 insertions(+) create mode 100644 core-java-collections/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java create mode 100644 core-java-collections/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java create mode 100644 core-java-collections/src/test/java/com/baeldung/copyinghashmap/Employee.java diff --git a/core-java-collections/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java new file mode 100644 index 0000000000..e6935afbe2 --- /dev/null +++ b/core-java-collections/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -0,0 +1,46 @@ +package com.baeldung.copyinghashmap; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import org.apache.commons.lang3.SerializationUtils; + +public class CopyHashMap { + + public static HashMap basicCopy(HashMap originalMap, HashMap copyMap) { + Set entries = originalMap.entrySet(); + for(Map.Entry mapEntry: entries) { + copyMap.put(mapEntry.getKey(), mapEntry.getValue()); + } + + return copyMap; + } + + + public static Map copyUsingPutAll(Map originalMap, Map copyMap) { + copyMap.putAll(originalMap); + + return copyMap; + } + + public static HashMap copyUsingJava8Stream(HashMap originalMap) { + Set entries = originalMap.entrySet(); + HashMap copyMap = (HashMap) entries + .stream() + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + + return copyMap; + } + + public static HashMap shallowCopy(HashMap originalMap) { + //return new HashMap(originalMap); + return (HashMap) originalMap.clone(); + } + + public static HashMap deepCopy(HashMap originalMap) { + return SerializationUtils.clone(originalMap); + } + +} diff --git a/core-java-collections/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java new file mode 100644 index 0000000000..57fccadaef --- /dev/null +++ b/core-java-collections/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -0,0 +1,100 @@ +package com.baeldung.copyinghashmap; + +import static org.junit.Assert.assertEquals; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +import com.google.common.collect.ImmutableMap; + +public class CopyHashMapUnitTest { + + @Test + public void givenHashmap_whenCopy_thenCopyContainsAllMappings() { + + HashMap colorMap = new HashMap<>(); + colorMap.put("1", "Red"); + colorMap.put("2", "Blue"); + colorMap.put("3", "Green"); + + System.out.println("ColorMap content : " + colorMap); + + HashMap colorMapCopy = new HashMap<>(); + colorMapCopy.put("1", "Orange"); + colorMapCopy.put("4", "Black"); + + colorMapCopy = CopyHashMap.basicCopy(colorMap, colorMapCopy); + + System.out.println("ColorMapCopy content : " +colorMapCopy); + + assertEquals(4, colorMapCopy.size()); + } + + @Test + public void givenHashMap_whenShallowCopy_thenCopyisNotSameAsOriginal() { + + HashMap employeeMap = new HashMap<>(); + Employee emp1 = new Employee("John", "Smith"); + Employee emp2 = new Employee("Norman", "Lewis"); + employeeMap.put("employee1",emp1); + employeeMap.put("employee2",emp2); + + HashMap employeeMapShallowCopy = CopyHashMap.shallowCopy(employeeMap); + + assertThat(employeeMapShallowCopy).isNotSameAs(employeeMap); + + } + + @Test + public void givenHashMap_whenShallowCopyModifyingOriginalObject_thenCopyShouldChange() { + + HashMap employeeMap = new HashMap<>(); + Employee emp1 = new Employee("John", "Smith"); + Employee emp2 = new Employee("Norman", "Lewis"); + employeeMap.put("employee1",emp1); + employeeMap.put("employee2",emp2); + HashMap employeeMapShallowCopy = CopyHashMap.shallowCopy(employeeMap); + + emp1.setFirstName("Johny"); + + assertThat(employeeMapShallowCopy.get("employee1")) + .isEqualTo(employeeMap.get("employee1")); + + } + + @Test + public void givenHashMap_whenDeepCopyModifyingOriginalObject_thenCopyShouldNotChange() { + + HashMap employeeMap = new HashMap<>(); + Employee emp1 = new Employee("John", "Smith"); + Employee emp2 = new Employee("Norman", "Lewis"); + employeeMap.put("employee1",emp1); + employeeMap.put("employee2",emp2); + HashMap employeeMapDeepCopy = CopyHashMap.deepCopy(employeeMap); + + emp1.setFirstName("Johny"); + + assertThat(employeeMapDeepCopy.get("employee1")) + .isNotEqualTo(employeeMap.get("employee1")); + + } + + @Test + public void givenImmutableMap_whenCopyUsingGuava_thenCopyShouldNotChange() { + + Map heightMap = ImmutableMap. builder() + .put("emp1", 160) + .put("emp2", 165) + .put("emp3", 163) + .build(); + Map heightMapCopy = ImmutableMap.copyOf(heightMap); + + assertThat(heightMapCopy).isSameAs(heightMap); + + } + + +} diff --git a/core-java-collections/src/test/java/com/baeldung/copyinghashmap/Employee.java b/core-java-collections/src/test/java/com/baeldung/copyinghashmap/Employee.java new file mode 100644 index 0000000000..9ec4327b5f --- /dev/null +++ b/core-java-collections/src/test/java/com/baeldung/copyinghashmap/Employee.java @@ -0,0 +1,38 @@ +package com.baeldung.copyinghashmap; + +import java.io.Serializable; + +public class Employee implements Serializable{ + + private String firstName; + private String lastName; + + public Employee(String firstName, String lastName) { + super(); + this.firstName = firstName; + this.lastName = lastName; + } + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + @Override + public String toString() { + return this.firstName + " " + this.lastName; + } + +} + + From 4878cc2716cc81f5d324bee098516a44a5f74483 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Wed, 3 Apr 2019 15:06:33 +0300 Subject: [PATCH 02/11] BAEL-2800_Copying_a_HashMap_in_Java new module added --- core-java-collections-2/README.md | 6 ++ core-java-collections-2/pom.xml | 78 +++++++++++++++++++ .../baeldung/copyinghashmap/CopyHashMap.java | 0 .../copyinghashmap/CopyHashMapUnitTest.java | 0 .../com/baeldung/copyinghashmap/Employee.java | 0 pom.xml | 2 + 6 files changed, 86 insertions(+) create mode 100644 core-java-collections-2/README.md create mode 100644 core-java-collections-2/pom.xml rename {core-java-collections => core-java-collections-2}/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java (100%) rename {core-java-collections => core-java-collections-2}/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java (100%) rename {core-java-collections => core-java-collections-2}/src/test/java/com/baeldung/copyinghashmap/Employee.java (100%) diff --git a/core-java-collections-2/README.md b/core-java-collections-2/README.md new file mode 100644 index 0000000000..da02928118 --- /dev/null +++ b/core-java-collections-2/README.md @@ -0,0 +1,6 @@ +========= + +## Core Java Collections 2 + +### Relevant Articles: +- Java - Copying a HashMap diff --git a/core-java-collections-2/pom.xml b/core-java-collections-2/pom.xml new file mode 100644 index 0000000000..677e6fd312 --- /dev/null +++ b/core-java-collections-2/pom.xml @@ -0,0 +1,78 @@ + + 4.0.0 + core-java-collections-2 + 0.1.0-SNAPSHOT + core-java-collections-2 + jar + + + com.baeldung + parent-java + 0.0.1-SNAPSHOT + ../parent-java + + + + + org.apache.commons + commons-collections4 + ${commons-collections4.version} + + + org.apache.commons + commons-lang3 + ${commons-lang3.version} + + + org.eclipse.collections + eclipse-collections + ${eclipse.collections.version} + + + org.assertj + assertj-core + ${assertj.version} + test + + + org.junit.platform + junit-platform-runner + ${junit.platform.version} + test + + + org.openjdk.jmh + jmh-core + ${openjdk.jmh.version} + + + org.openjdk.jmh + jmh-generator-annprocess + ${openjdk.jmh.version} + + + org.apache.commons + commons-exec + ${commons-exec.version} + + + org.projectlombok + lombok + ${lombok.version} + provided + + + + + 1.19 + 1.2.0 + 3.8.1 + 4.1 + 4.01 + 1.7.0 + 3.11.1 + 7.1.0 + 1.3 + + diff --git a/core-java-collections/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java similarity index 100% rename from core-java-collections/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java rename to core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java diff --git a/core-java-collections/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java similarity index 100% rename from core-java-collections/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java rename to core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java diff --git a/core-java-collections/src/test/java/com/baeldung/copyinghashmap/Employee.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java similarity index 100% rename from core-java-collections/src/test/java/com/baeldung/copyinghashmap/Employee.java rename to core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java diff --git a/pom.xml b/pom.xml index 615fc7b46e..6da150bb61 100644 --- a/pom.xml +++ b/pom.xml @@ -383,6 +383,7 @@ core-java-arrays core-java-collections + core-java-collections-2 core-java-collections-list core-java-concurrency-basic core-java-concurrency-collections @@ -1030,6 +1031,7 @@ core-java-arrays core-java-collections + core-java-collections-2 core-java-collections-list core-java-concurrency-basic core-java-concurrency-collections From cdb37dddda62807df8686e7bb77cfcb0ba8cc4cd Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Wed, 3 Apr 2019 17:14:31 +0300 Subject: [PATCH 03/11] BAEL-2800_Copying_a_HashMap_in_Java - methods added --- .../baeldung/copyinghashmap/CopyHashMap.java | 25 ++++++++++-- .../copyinghashmap/CopyHashMapUnitTest.java | 38 ++++++++----------- 2 files changed, 36 insertions(+), 27 deletions(-) diff --git a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java index e6935afbe2..a1dc4fe6bb 100644 --- a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java +++ b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -8,8 +8,17 @@ import java.util.stream.Collectors; import org.apache.commons.lang3.SerializationUtils; public class CopyHashMap { + + public static HashMap copyUsingConstructor(HashMap originalMap) { + return new HashMap(originalMap); + } + + public static HashMap copyUsingClone(HashMap originalMap) { + return (HashMap) originalMap.clone(); + } - public static HashMap basicCopy(HashMap originalMap, HashMap copyMap) { + public static HashMap copyUsingPut(HashMap originalMap) { + HashMap copyMap = new HashMap(); Set entries = originalMap.entrySet(); for(Map.Entry mapEntry: entries) { copyMap.put(mapEntry.getKey(), mapEntry.getValue()); @@ -18,8 +27,8 @@ public class CopyHashMap { return copyMap; } - - public static Map copyUsingPutAll(Map originalMap, Map copyMap) { + public static Map copyUsingPutAll(Map originalMap) { + HashMap copyMap = new HashMap(); copyMap.putAll(originalMap); return copyMap; @@ -34,8 +43,16 @@ public class CopyHashMap { return copyMap; } + public static HashMap copyMapAndConvertCmsToInches(HashMap originalMap) { + Set entries = originalMap.entrySet(); + HashMap copyMap = (HashMap) entries + .stream() + .collect(Collectors.toMap(mapEntry -> mapEntry.getKey(), mapEntry -> (int)mapEntry.getValue()/2.54)); + + return copyMap; + } + public static HashMap shallowCopy(HashMap originalMap) { - //return new HashMap(originalMap); return (HashMap) originalMap.clone(); } diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java index 57fccadaef..d49317b3dc 100644 --- a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java +++ b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -12,27 +12,6 @@ import com.google.common.collect.ImmutableMap; public class CopyHashMapUnitTest { - @Test - public void givenHashmap_whenCopy_thenCopyContainsAllMappings() { - - HashMap colorMap = new HashMap<>(); - colorMap.put("1", "Red"); - colorMap.put("2", "Blue"); - colorMap.put("3", "Green"); - - System.out.println("ColorMap content : " + colorMap); - - HashMap colorMapCopy = new HashMap<>(); - colorMapCopy.put("1", "Orange"); - colorMapCopy.put("4", "Black"); - - colorMapCopy = CopyHashMap.basicCopy(colorMap, colorMapCopy); - - System.out.println("ColorMapCopy content : " +colorMapCopy); - - assertEquals(4, colorMapCopy.size()); - } - @Test public void givenHashMap_whenShallowCopy_thenCopyisNotSameAsOriginal() { @@ -80,7 +59,21 @@ public class CopyHashMapUnitTest { assertThat(employeeMapDeepCopy.get("employee1")) .isNotEqualTo(employeeMap.get("employee1")); - } + } + + @Test + public void givenHashMapWithValuesInCms_whenCopy_thenCopyMapShouldHaveValuesInInches() { + + HashMap heightMap = new HashMap<>(); + heightMap.put("emp1", 160); + heightMap.put("emp2", 165); + heightMap.put("emp3", 163); + HashMap heightMapInInches = CopyHashMap.copyMapAndConvertCmsToInches(heightMap); + + assertThat(heightMap).isNotEqualTo(heightMapInInches); + + assertThat(heightMap.get("emp1")/2.54).isEqualTo(heightMapInInches.get("emp1")); + } @Test public void givenImmutableMap_whenCopyUsingGuava_thenCopyShouldNotChange() { @@ -95,6 +88,5 @@ public class CopyHashMapUnitTest { assertThat(heightMapCopy).isSameAs(heightMap); } - } From 8455bfc1d0536647cf179fbabb09bb14e1f6e130 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Fri, 5 Apr 2019 10:48:46 +0300 Subject: [PATCH 04/11] BAEL-2800_Copying_a_HashMap_in_Java - space problem fix --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 6da150bb61..1f3901111d 100644 --- a/pom.xml +++ b/pom.xml @@ -1031,7 +1031,7 @@ core-java-arrays core-java-collections - core-java-collections-2 + core-java-collections-2 core-java-collections-list core-java-concurrency-basic core-java-concurrency-collections From b17c1c720f9d719c8877f04402b32eeeb7e8dd9b Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Fri, 5 Apr 2019 12:53:14 +0300 Subject: [PATCH 05/11] BAEL-2800_Copying_a_HashMap_in_Java - code cleanup --- .../baeldung/copyinghashmap/CopyHashMap.java | 4 +- .../copyinghashmap/CopyHashMapUnitTest.java | 57 +++++++++---------- .../com/baeldung/copyinghashmap/Employee.java | 26 +++------ 3 files changed, 38 insertions(+), 49 deletions(-) diff --git a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java index a1dc4fe6bb..11ead4ee38 100644 --- a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java +++ b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -43,11 +43,11 @@ public class CopyHashMap { return copyMap; } - public static HashMap copyMapAndConvertCmsToInches(HashMap originalMap) { + public static HashMap copyMapAndDivideValuesBy2(HashMap originalMap) { Set entries = originalMap.entrySet(); HashMap copyMap = (HashMap) entries .stream() - .collect(Collectors.toMap(mapEntry -> mapEntry.getKey(), mapEntry -> (int)mapEntry.getValue()/2.54)); + .collect(Collectors.toMap(mapEntry -> mapEntry.getKey(), mapEntry -> (int)mapEntry.getValue()/2)); return copyMap; } diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java index d49317b3dc..91848a86a9 100644 --- a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java +++ b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -15,64 +15,63 @@ public class CopyHashMapUnitTest { @Test public void givenHashMap_whenShallowCopy_thenCopyisNotSameAsOriginal() { - HashMap employeeMap = new HashMap<>(); - Employee emp1 = new Employee("John", "Smith"); - Employee emp2 = new Employee("Norman", "Lewis"); - employeeMap.put("employee1",emp1); - employeeMap.put("employee2",emp2); + HashMap map = new HashMap<>(); + Employee emp1 = new Employee("John"); + Employee emp2 = new Employee("Norman"); + map.put("emp1",emp1); + map.put("emp2",emp2); - HashMap employeeMapShallowCopy = CopyHashMap.shallowCopy(employeeMap); + HashMap shallowCopy = CopyHashMap.shallowCopy(map); - assertThat(employeeMapShallowCopy).isNotSameAs(employeeMap); + assertThat(shallowCopy).isNotSameAs(map); } @Test public void givenHashMap_whenShallowCopyModifyingOriginalObject_thenCopyShouldChange() { - HashMap employeeMap = new HashMap<>(); - Employee emp1 = new Employee("John", "Smith"); - Employee emp2 = new Employee("Norman", "Lewis"); - employeeMap.put("employee1",emp1); - employeeMap.put("employee2",emp2); - HashMap employeeMapShallowCopy = CopyHashMap.shallowCopy(employeeMap); + HashMap map = new HashMap<>(); + Employee emp1 = new Employee("John"); + Employee emp2 = new Employee("Norman"); + map.put("emp1",emp1); + map.put("emp2",emp2); - emp1.setFirstName("Johny"); + HashMap shallowCopy = CopyHashMap.shallowCopy(map); - assertThat(employeeMapShallowCopy.get("employee1")) - .isEqualTo(employeeMap.get("employee1")); + emp1.setName("Johny"); + + assertThat(shallowCopy.get("emp1")).isEqualTo(map.get("emp1")); } @Test public void givenHashMap_whenDeepCopyModifyingOriginalObject_thenCopyShouldNotChange() { - HashMap employeeMap = new HashMap<>(); - Employee emp1 = new Employee("John", "Smith"); - Employee emp2 = new Employee("Norman", "Lewis"); - employeeMap.put("employee1",emp1); - employeeMap.put("employee2",emp2); - HashMap employeeMapDeepCopy = CopyHashMap.deepCopy(employeeMap); + HashMap map = new HashMap<>(); + Employee emp1 = new Employee("John"); + Employee emp2 = new Employee("Norman"); + map.put("emp1",emp1); + map.put("emp2",emp2); + HashMap deepCopy = CopyHashMap.deepCopy(map); - emp1.setFirstName("Johny"); + emp1.setName("Johny"); - assertThat(employeeMapDeepCopy.get("employee1")) - .isNotEqualTo(employeeMap.get("employee1")); + assertThat(deepCopy.get("emp1")).isNotEqualTo(map.get("emp1")); } @Test - public void givenHashMapWithValuesInCms_whenCopy_thenCopyMapShouldHaveValuesInInches() { + public void givenHashMap_whenCopy_thenCopyMapShouldHaveValuesDivideBy2() { HashMap heightMap = new HashMap<>(); heightMap.put("emp1", 160); heightMap.put("emp2", 165); heightMap.put("emp3", 163); - HashMap heightMapInInches = CopyHashMap.copyMapAndConvertCmsToInches(heightMap); + HashMap heightMapCopy = CopyHashMap.copyMapAndDivideValuesBy2(heightMap); - assertThat(heightMap).isNotEqualTo(heightMapInInches); + assertThat(heightMap).isNotEqualTo(heightMapCopy); - assertThat(heightMap.get("emp1")/2.54).isEqualTo(heightMapInInches.get("emp1")); + assertThat(heightMap.get("emp1")/2).isEqualTo(heightMapCopy.get("emp1")); } @Test diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java index 9ec4327b5f..b47fdc768e 100644 --- a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java +++ b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java @@ -4,33 +4,23 @@ import java.io.Serializable; public class Employee implements Serializable{ - private String firstName; - private String lastName; + private String name; - public Employee(String firstName, String lastName) { + public Employee(String name) { super(); - this.firstName = firstName; - this.lastName = lastName; + this.name = name; } - public String getFirstName() { - return firstName; + public String getName() { + return name; } - public void setFirstName(String firstName) { - this.firstName = firstName; - } - - public String getLastName() { - return lastName; - } - - public void setLastName(String lastName) { - this.lastName = lastName; + public void setName(String name) { + this.name = name; } @Override public String toString() { - return this.firstName + " " + this.lastName; + return this.name; } } From 96903671b60c180c519cee18e53f73a932c326b3 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Sat, 6 Apr 2019 07:47:46 +0300 Subject: [PATCH 06/11] BAEL-2800_Copying_a_HashMap_in_Java --- .../copyinghashmap/CopyHashMapUnitTest.java | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java index 91848a86a9..ce41e9d810 100644 --- a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java +++ b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -76,15 +76,16 @@ public class CopyHashMapUnitTest { @Test public void givenImmutableMap_whenCopyUsingGuava_thenCopyShouldNotChange() { + Employee emp1 = new Employee("John"); + Employee emp2 = new Employee("Norman"); - Map heightMap = ImmutableMap. builder() - .put("emp1", 160) - .put("emp2", 165) - .put("emp3", 163) + Map map = ImmutableMap. builder() + .put("emp1",emp1) + .put("emp2",emp2) .build(); - Map heightMapCopy = ImmutableMap.copyOf(heightMap); + Map mapCopy = ImmutableMap.copyOf(map); - assertThat(heightMapCopy).isSameAs(heightMap); + assertThat(mapCopy).isSameAs(map); } From 68ffec2c2cea5dc021003e7ae95b4f6138114020 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Sat, 6 Apr 2019 07:49:57 +0300 Subject: [PATCH 07/11] BAEL-2800_Copying_a_HashMap_in_Java --- .../com/baeldung/copyinghashmap/CopyHashMap.java | 9 --------- .../copyinghashmap/CopyHashMapUnitTest.java | 16 +--------------- 2 files changed, 1 insertion(+), 24 deletions(-) diff --git a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java index 11ead4ee38..e673335f62 100644 --- a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java +++ b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -43,15 +43,6 @@ public class CopyHashMap { return copyMap; } - public static HashMap copyMapAndDivideValuesBy2(HashMap originalMap) { - Set entries = originalMap.entrySet(); - HashMap copyMap = (HashMap) entries - .stream() - .collect(Collectors.toMap(mapEntry -> mapEntry.getKey(), mapEntry -> (int)mapEntry.getValue()/2)); - - return copyMap; - } - public static HashMap shallowCopy(HashMap originalMap) { return (HashMap) originalMap.clone(); } diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java index ce41e9d810..f0434f9bfe 100644 --- a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java +++ b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -58,21 +58,7 @@ public class CopyHashMapUnitTest { assertThat(deepCopy.get("emp1")).isNotEqualTo(map.get("emp1")); - } - - @Test - public void givenHashMap_whenCopy_thenCopyMapShouldHaveValuesDivideBy2() { - - HashMap heightMap = new HashMap<>(); - heightMap.put("emp1", 160); - heightMap.put("emp2", 165); - heightMap.put("emp3", 163); - HashMap heightMapCopy = CopyHashMap.copyMapAndDivideValuesBy2(heightMap); - - assertThat(heightMap).isNotEqualTo(heightMapCopy); - - assertThat(heightMap.get("emp1")/2).isEqualTo(heightMapCopy.get("emp1")); - } + } @Test public void givenImmutableMap_whenCopyUsingGuava_thenCopyShouldNotChange() { From aae74f3b6cce2260442e9c3469f0f22a0f22c319 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Mon, 8 Apr 2019 11:08:20 +0300 Subject: [PATCH 08/11] BAEL-2800_Copying_a_HashMap_in_Java - generic types added --- .../baeldung/copyinghashmap/CopyHashMap.java | 35 ++++++++++--------- .../copyinghashmap/CopyHashMapUnitTest.java | 7 ++-- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java index e673335f62..972f48a3bf 100644 --- a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java +++ b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -2,6 +2,7 @@ package com.baeldung.copyinghashmap; import java.util.HashMap; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; import java.util.stream.Collectors; @@ -9,45 +10,45 @@ import org.apache.commons.lang3.SerializationUtils; public class CopyHashMap { - public static HashMap copyUsingConstructor(HashMap originalMap) { - return new HashMap(originalMap); + public static HashMap copyUsingConstructor(HashMap originalMap) { + return new HashMap(originalMap); } - public static HashMap copyUsingClone(HashMap originalMap) { - return (HashMap) originalMap.clone(); + public static HashMap copyUsingClone(HashMap originalMap) { + return (HashMap) originalMap.clone(); } - public static HashMap copyUsingPut(HashMap originalMap) { - HashMap copyMap = new HashMap(); - Set entries = originalMap.entrySet(); - for(Map.Entry mapEntry: entries) { - copyMap.put(mapEntry.getKey(), mapEntry.getValue()); + public static HashMap copyUsingPut(HashMap originalMap) { + HashMap copyMap = new HashMap(); + Set> entries = originalMap.entrySet(); + for(Map.Entry mapEntry: entries) { + copyMap.put((K)mapEntry.getKey(), (V)mapEntry.getValue()); } return copyMap; } - public static Map copyUsingPutAll(Map originalMap) { - HashMap copyMap = new HashMap(); + public static HashMap copyUsingPutAll(HashMap originalMap) { + HashMap copyMap = new HashMap(); copyMap.putAll(originalMap); return copyMap; } - public static HashMap copyUsingJava8Stream(HashMap originalMap) { - Set entries = originalMap.entrySet(); - HashMap copyMap = (HashMap) entries + public static HashMap copyUsingJava8Stream(HashMap originalMap) { + Set> entries = originalMap.entrySet(); + HashMap copyMap = (HashMap) entries .stream() .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); return copyMap; } - public static HashMap shallowCopy(HashMap originalMap) { - return (HashMap) originalMap.clone(); + public static HashMap shallowCopy(HashMap originalMap) { + return (HashMap) originalMap.clone(); } - public static HashMap deepCopy(HashMap originalMap) { + public static HashMap deepCopy(HashMap originalMap) { return SerializationUtils.clone(originalMap); } diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java index f0434f9bfe..c71e17e94e 100644 --- a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java +++ b/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -1,6 +1,5 @@ package com.baeldung.copyinghashmap; -import static org.junit.Assert.assertEquals; import static org.assertj.core.api.Assertions.assertThat; import java.util.HashMap; @@ -21,7 +20,7 @@ public class CopyHashMapUnitTest { map.put("emp1",emp1); map.put("emp2",emp2); - HashMap shallowCopy = CopyHashMap.shallowCopy(map); + HashMap shallowCopy = CopyHashMap.shallowCopy(map); assertThat(shallowCopy).isNotSameAs(map); @@ -36,7 +35,7 @@ public class CopyHashMapUnitTest { map.put("emp1",emp1); map.put("emp2",emp2); - HashMap shallowCopy = CopyHashMap.shallowCopy(map); + HashMap shallowCopy = CopyHashMap.shallowCopy(map); emp1.setName("Johny"); @@ -52,7 +51,7 @@ public class CopyHashMapUnitTest { Employee emp2 = new Employee("Norman"); map.put("emp1",emp1); map.put("emp2",emp2); - HashMap deepCopy = CopyHashMap.deepCopy(map); + HashMap deepCopy = CopyHashMap.deepCopy(map); emp1.setName("Johny"); From 58f416fbb86649f75f3efdcacf2c48248e83474b Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Tue, 9 Apr 2019 07:22:59 +0300 Subject: [PATCH 09/11] BAEL-2800_Copying_a_HashMap_in_Java - types corrected --- .../baeldung/copyinghashmap/CopyHashMap.java | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java index 972f48a3bf..cd81f61b48 100644 --- a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java +++ b/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -10,45 +10,45 @@ import org.apache.commons.lang3.SerializationUtils; public class CopyHashMap { - public static HashMap copyUsingConstructor(HashMap originalMap) { - return new HashMap(originalMap); + public static HashMap copyUsingConstructor(HashMap originalMap) { + return new HashMap(originalMap); } - public static HashMap copyUsingClone(HashMap originalMap) { - return (HashMap) originalMap.clone(); + public static HashMap copyUsingClone(HashMap originalMap) { + return (HashMap) originalMap.clone(); } - public static HashMap copyUsingPut(HashMap originalMap) { - HashMap copyMap = new HashMap(); - Set> entries = originalMap.entrySet(); - for(Map.Entry mapEntry: entries) { - copyMap.put((K)mapEntry.getKey(), (V)mapEntry.getValue()); + public static HashMap copyUsingPut(HashMap originalMap) { + HashMap copyMap = new HashMap(); + Set> entries = originalMap.entrySet(); + for(Map.Entry mapEntry: entries) { + copyMap.put(mapEntry.getKey(), mapEntry.getValue()); } return copyMap; } - public static HashMap copyUsingPutAll(HashMap originalMap) { - HashMap copyMap = new HashMap(); + public static HashMap copyUsingPutAll(HashMap originalMap) { + HashMap copyMap = new HashMap(); copyMap.putAll(originalMap); return copyMap; } - public static HashMap copyUsingJava8Stream(HashMap originalMap) { - Set> entries = originalMap.entrySet(); - HashMap copyMap = (HashMap) entries + public static HashMap copyUsingJava8Stream(HashMap originalMap) { + Set> entries = originalMap.entrySet(); + HashMap copyMap = (HashMap) entries .stream() .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); return copyMap; } - public static HashMap shallowCopy(HashMap originalMap) { - return (HashMap) originalMap.clone(); + public static HashMap shallowCopy(HashMap originalMap) { + return (HashMap) originalMap.clone(); } - public static HashMap deepCopy(HashMap originalMap) { + public static HashMap deepCopy(HashMap originalMap) { return SerializationUtils.clone(originalMap); } From 998e2b7eeb4cd08afb682dfad3955fe06d4018dc Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Wed, 10 Apr 2019 16:55:52 +0300 Subject: [PATCH 10/11] BAEL-2800_Copying_a_HashMap_in_Java - module renamed to core-java-collections-map --- .../README.md | 0 .../pom.xml | 4 ++-- .../main/java/com/baeldung/copyinghashmap/CopyHashMap.java | 0 .../java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java | 0 .../src/test/java/com/baeldung/copyinghashmap/Employee.java | 0 pom.xml | 4 ++-- 6 files changed, 4 insertions(+), 4 deletions(-) rename {core-java-collections-2 => core-java-collections-map}/README.md (100%) rename {core-java-collections-2 => core-java-collections-map}/pom.xml (96%) rename {core-java-collections-2 => core-java-collections-map}/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java (100%) rename {core-java-collections-2 => core-java-collections-map}/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java (100%) rename {core-java-collections-2 => core-java-collections-map}/src/test/java/com/baeldung/copyinghashmap/Employee.java (100%) diff --git a/core-java-collections-2/README.md b/core-java-collections-map/README.md similarity index 100% rename from core-java-collections-2/README.md rename to core-java-collections-map/README.md diff --git a/core-java-collections-2/pom.xml b/core-java-collections-map/pom.xml similarity index 96% rename from core-java-collections-2/pom.xml rename to core-java-collections-map/pom.xml index 677e6fd312..8c0aef54bf 100644 --- a/core-java-collections-2/pom.xml +++ b/core-java-collections-map/pom.xml @@ -1,9 +1,9 @@ 4.0.0 - core-java-collections-2 + core-java-collections-map 0.1.0-SNAPSHOT - core-java-collections-2 + core-java-collections-map jar diff --git a/core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-map/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java similarity index 100% rename from core-java-collections-2/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java rename to core-java-collections-map/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java similarity index 100% rename from core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java rename to core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java diff --git a/core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java b/core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/Employee.java similarity index 100% rename from core-java-collections-2/src/test/java/com/baeldung/copyinghashmap/Employee.java rename to core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/Employee.java diff --git a/pom.xml b/pom.xml index 1f3901111d..a0b2948752 100644 --- a/pom.xml +++ b/pom.xml @@ -383,7 +383,7 @@ core-java-arrays core-java-collections - core-java-collections-2 + core-java-collections-map core-java-collections-list core-java-concurrency-basic core-java-concurrency-collections @@ -1031,7 +1031,7 @@ core-java-arrays core-java-collections - core-java-collections-2 + core-java-collections-map core-java-collections-list core-java-concurrency-basic core-java-concurrency-collections From 437efd7242b94e4a9570a2ef07e25698272905c0 Mon Sep 17 00:00:00 2001 From: Anshul Bansal Date: Wed, 10 Apr 2019 16:56:53 +0300 Subject: [PATCH 11/11] BAEL-2800_Copying_a_HashMap_in_Java --- .../com/baeldung/copyinghashmap/CopyHashMap.java | 16 ++++++++-------- .../copyinghashmap/CopyHashMapUnitTest.java | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/core-java-collections-map/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java b/core-java-collections-map/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java index cd81f61b48..e1649f593c 100644 --- a/core-java-collections-map/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java +++ b/core-java-collections-map/src/main/java/com/baeldung/copyinghashmap/CopyHashMap.java @@ -19,29 +19,29 @@ public class CopyHashMap { } public static HashMap copyUsingPut(HashMap originalMap) { - HashMap copyMap = new HashMap(); + HashMap shallowCopy = new HashMap(); Set> entries = originalMap.entrySet(); for(Map.Entry mapEntry: entries) { - copyMap.put(mapEntry.getKey(), mapEntry.getValue()); + shallowCopy.put(mapEntry.getKey(), mapEntry.getValue()); } - return copyMap; + return shallowCopy; } public static HashMap copyUsingPutAll(HashMap originalMap) { - HashMap copyMap = new HashMap(); - copyMap.putAll(originalMap); + HashMap shallowCopy = new HashMap(); + shallowCopy.putAll(originalMap); - return copyMap; + return shallowCopy; } public static HashMap copyUsingJava8Stream(HashMap originalMap) { Set> entries = originalMap.entrySet(); - HashMap copyMap = (HashMap) entries + HashMap shallowCopy = (HashMap) entries .stream() .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); - return copyMap; + return shallowCopy; } public static HashMap shallowCopy(HashMap originalMap) { diff --git a/core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java b/core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java index c71e17e94e..400696d97a 100644 --- a/core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java +++ b/core-java-collections-map/src/test/java/com/baeldung/copyinghashmap/CopyHashMapUnitTest.java @@ -68,9 +68,9 @@ public class CopyHashMapUnitTest { .put("emp1",emp1) .put("emp2",emp2) .build(); - Map mapCopy = ImmutableMap.copyOf(map); + Map shallowCopy = ImmutableMap.copyOf(map); - assertThat(mapCopy).isSameAs(map); + assertThat(shallowCopy).isSameAs(map); }