[BAEL-9550] - Moved articles and codes from core-java-collections module to java-collections-convversions and java-collections-maps module

java-collections-maps/src/main/java/com/baeldung/java/map/MapUtil.java

@@ -0,0 +1,44 @@
+/**
+ * 
+ */
+package com.baeldung.java.map;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.stream.Stream;
+
+/**
+ * @author swpraman
+ *
+ */
+public class MapUtil {
+    
+    public static <K, V> Stream<K> keys(Map<K, V> map, V value) {
+        return map.entrySet()
+                .stream()
+                .filter(entry -> value.equals(entry.getValue()))
+                .map(Map.Entry::getKey);
+    }
+    
+    public static <K, V> Set<K> getKeys(Map<K, V> map, V value) {
+        Set<K> keys = new HashSet<>();
+        for (Entry<K, V> entry : map.entrySet()) {
+            if (entry.getValue().equals(value)) {
+                keys.add(entry.getKey());
+            }
+        }
+        return keys;
+    }
+    
+    public static <K, V> K getKey(Map<K, V> map, V value) {
+        for (Entry<K, V> entry : map.entrySet()) {
+            if (entry.getValue().equals(value)) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+
+}

java-collections-maps/src/main/java/com/baeldung/java/map/MyKey.java

@@ -0,0 +1,64 @@
+package com.baeldung.java.map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MyKey {
+    private static final Logger LOG = LoggerFactory.getLogger(MyKey.class);
+    
+    private String name;
+    private int id;
+
+    public MyKey(int id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    @Override
+    public int hashCode() {
+        LOG.debug("Calling hashCode()");
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return "MyKey [name=" + name + ", id=" + id + "]";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        LOG.debug("Calling equals() for key: " + obj);
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        MyKey other = (MyKey) obj;
+        if (id != other.id)
+            return false;
+        if (name == null) {
+            if (other.name != null)
+                return false;
+        } else if (!name.equals(other.name))
+            return false;
+        return true;
+    }
+
+}

java-collections-maps/src/main/java/com/baeldung/java/map/MyLinkedHashMap.java

@@ -0,0 +1,23 @@
+package com.baeldung.java.map;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class MyLinkedHashMap<K, V> extends LinkedHashMap<K, V> {
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+    private static final int MAX_ENTRIES = 5;
+
+    public MyLinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
+        super(initialCapacity, loadFactor, accessOrder);
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Map.Entry eldest) {
+        return size() > MAX_ENTRIES;
+    }
+
+}

java-collections-maps/src/main/java/com/baeldung/java/map/initialize/MapInitializer.java

@@ -0,0 +1,80 @@
+package com.baeldung.java.map.initialize;
+
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MapInitializer {
+
+    public static Map<String, String> articleMapOne;
+    static {
+        articleMapOne = new HashMap<>();
+        articleMapOne.put("ar01", "Intro to Map");
+        articleMapOne.put("ar02", "Some article");
+    }
+
+    public static Map<String, String> createSingletonMap() {
+        Map<String, String> passwordMap = Collections.singletonMap("username1", "password1");
+        return passwordMap;
+
+    }
+
+    public Map<String, String> createEmptyMap() {
+        Map<String, String> emptyMap = Collections.emptyMap();
+        return emptyMap;
+    }
+
+    public Map<String, String> createUsingDoubleBrace() {
+        Map<String, String> doubleBraceMap = new HashMap<String, String>() {
+
+            /**
+             * 
+             */
+            private static final long serialVersionUID = 1L;
+
+            {
+                put("key1", "value1");
+                put("key2", "value2");
+            }
+        };
+        return doubleBraceMap;
+    }
+
+    public Map<String, String> createMapUsingStreamStringArray() {
+        Map<String, String> map = Stream.of(new String[][] { { "Hello", "World" }, { "John", "Doe" }, })
+            .collect(Collectors.toMap(data -> data[0], data -> data[1]));
+
+        return map;
+    }
+
+    public Map<String, Integer> createMapUsingStreamObjectArray() {
+        Map<String, Integer> map = Stream.of(new Object[][] { { "data1", 1 }, { "data2", 2 }, })
+            .collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));
+
+        return map;
+    }
+
+    public Map<String, Integer> createMapUsingStreamSimpleEntry() {
+        Map<String, Integer> map = Stream.of(new AbstractMap.SimpleEntry<>("idea", 1), new AbstractMap.SimpleEntry<>("mobile", 2))
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        return map;
+    }
+
+    public Map<String, Integer> createMapUsingStreamSimpleImmutableEntry() {
+        Map<String, Integer> map = Stream.of(new AbstractMap.SimpleImmutableEntry<>("idea", 1), new AbstractMap.SimpleImmutableEntry<>("mobile", 2))
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        return map;
+    }
+
+    public Map<String, String> createImmutableMapWithStreams() {
+        Map<String, String> map = Stream.of(new String[][] { { "Hello", "World" }, { "John", "Doe" }, })
+            .collect(Collectors.collectingAndThen(Collectors.toMap(data -> data[0], data -> data[1]), Collections::<String, String> unmodifiableMap));
+        return map;
+
+    }
+}

java-collections-maps/src/main/java/com/baeldung/map/iteration/MapIteration.java

@@ -0,0 +1,74 @@
+package com.baeldung.map.iteration;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public class MapIteration {
+
+    public static void main(String[] args) {
+        MapIteration mapIteration = new MapIteration();
+        Map<String, Integer> map = new HashMap<>();
+
+        map.put("One", 1);
+        map.put("Three", 3);
+        map.put("Two", 2);
+
+        System.out.println("Iterating Keys of Map Using KeySet");
+        mapIteration.iterateKeys(map);
+
+        System.out.println("Iterating Map Using Entry Set");
+        mapIteration.iterateUsingEntrySet(map);
+
+        System.out.println("Iterating Using Iterator and Map Entry");
+        mapIteration.iterateUsingIteratorAndEntry(map);
+
+        System.out.println("Iterating Using KeySet and For Each");
+        mapIteration.iterateUsingKeySetAndForeach(map);
+
+        System.out.println("Iterating Map Using Lambda Expression");
+        mapIteration.iterateUsingLambda(map);
+
+        System.out.println("Iterating Using Stream API");
+        mapIteration.iterateUsingStreamAPI(map);
+    }
+
+    public void iterateUsingEntrySet(Map<String, Integer> map) {
+        for (Map.Entry<String, Integer> entry : map.entrySet()) {
+            System.out.println(entry.getKey() + ":" + entry.getValue());
+        }
+    }
+
+    public void iterateUsingLambda(Map<String, Integer> map) {
+        map.forEach((k, v) -> System.out.println((k + ":" + v)));
+    }
+
+    public void iterateUsingIteratorAndEntry(Map<String, Integer> map) {
+        Iterator<Map.Entry<String, Integer>> iterator = map.entrySet()
+            .iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<String, Integer> pair = iterator.next();
+            System.out.println(pair.getKey() + ":" + pair.getValue());
+        }
+    }
+
+    public void iterateUsingKeySetAndForeach(Map<String, Integer> map) {
+        for (String key : map.keySet()) {
+            System.out.println(key + ":" + map.get(key));
+        }
+    }
+
+    public void iterateUsingStreamAPI(Map<String, Integer> map) {
+        map.entrySet()
+            .stream()
+            .forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
+    }
+
+    public void iterateKeys(Map<String, Integer> map) {
+        for (String key : map.keySet()) {
+            System.out.println(key);
+        }
+
+    }
+
+}

java-collections-maps/src/main/java/com/baeldung/map/java_8/MergeMaps.java

@@ -0,0 +1,105 @@
+package com.baeldung.map.java_8;
+
+import com.baeldung.sort.Employee;
+import one.util.streamex.EntryStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MergeMaps {
+
+    private static Map<String, Employee> map1 = new HashMap<>();
+    private static Map<String, Employee> map2 = new HashMap<>();
+
+    public static void main(String[] args) {
+
+        initialize();
+
+        mergeFunction();
+
+        streamConcat();
+
+        streamOf();
+
+        streamEx();
+
+        streamMerge();
+    }
+
+    private static void streamMerge() {
+
+        Map<String, Employee> map3 = map2.entrySet()
+                .stream()
+                .collect(
+                        Collectors.toMap(
+                                Map.Entry::getKey,
+                                Map.Entry::getValue,
+                                (v1, v2) -> new Employee(v1.getId(), v2.getName()),
+                                () -> new HashMap<>(map1)
+                        )
+                );
+
+        System.out.println(map3);
+    }
+
+    private static void streamEx() {
+        Map<String, Employee> map3 = EntryStream.of(map1)
+                .append(EntryStream.of(map2))
+                .toMap((e1, e2) -> e1);
+
+        System.out.println(map3);
+
+    }
+
+    private static void streamOf() {
+        Map<String, Employee> map3 = Stream.of(map1, map2)
+                .flatMap(map -> map.entrySet().stream())
+                .collect(
+                        Collectors.toMap(
+                                Map.Entry::getKey,
+                                Map.Entry::getValue,
+                                (v1, v2) -> new Employee(v1.getId(), v2.getName())
+                        )
+                );
+
+        map3.entrySet().forEach(System.out::println);
+    }
+
+    private static void streamConcat() {
+        Map<String, Employee> result = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream()).collect(Collectors.toMap(
+                Map.Entry::getKey,
+                Map.Entry::getValue,
+                (value1, value2) -> new Employee(value2.getId(), value1.getName())
+        ));
+
+        result.entrySet().forEach(System.out::println);
+    }
+
+    private static void mergeFunction() {
+        Map<String, Employee> map3 = new HashMap<>(map1);
+
+        map2.forEach(
+                (key, value) -> map3.merge(key, value, (v1, v2) ->
+                        new Employee(v1.getId(), v2.getName()))
+        );
+
+        map3.entrySet().forEach(System.out::println);
+    }
+
+
+    private static void initialize() {
+        Employee employee1 = new Employee(1L, "Henry");
+        map1.put(employee1.getName(), employee1);
+        Employee employee2 = new Employee(22L, "Annie");
+        map1.put(employee2.getName(), employee2);
+        Employee employee3 = new Employee(8L, "John");
+        map1.put(employee3.getName(), employee3);
+
+        Employee employee4 = new Employee(2L, "George");
+        map2.put(employee4.getName(), employee4);
+        Employee employee5 = new Employee(3L, "Henry");
+        map2.put(employee5.getName(), employee5);
+    }
+
+}

java-collections-maps/src/main/java/com/baeldung/map/util/MapMax.java

@@ -0,0 +1,96 @@
+package com.baeldung.map.util;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+
+public class MapMax {
+
+    public <K, V extends Comparable<V>> V maxUsingIteration(Map<K, V> map) {
+
+        Map.Entry<K, V> maxEntry = null;
+
+        for (Map.Entry<K, V> entry : map.entrySet()) {
+
+            if (maxEntry == null || entry.getValue()
+                .compareTo(maxEntry.getValue()) > 0) {
+                maxEntry = entry;
+            }
+        }
+
+        return maxEntry.getValue();
+    }
+
+    public <K, V extends Comparable<V>> V maxUsingCollectionsMax(Map<K, V> map) {
+
+        Entry<K, V> maxEntry = Collections.max(map.entrySet(), new Comparator<Entry<K, V>>() {
+            public int compare(Entry<K, V> e1, Entry<K, V> e2) {
+                return e1.getValue()
+                    .compareTo(e2.getValue());
+            }
+        });
+
+        return maxEntry.getValue();
+    }
+
+    public <K, V extends Comparable<V>> V maxUsingCollectionsMaxAndLambda(Map<K, V> map) {
+
+        Entry<K, V> maxEntry = Collections.max(map.entrySet(), (Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue()
+            .compareTo(e2.getValue()));
+
+        return maxEntry.getValue();
+    }
+
+    public <K, V extends Comparable<V>> V maxUsingCollectionsMaxAndMethodReference(Map<K, V> map) {
+
+        Entry<K, V> maxEntry = Collections.max(map.entrySet(), Comparator.comparing(Map.Entry::getValue));
+
+        return maxEntry.getValue();
+    }
+
+    public <K, V extends Comparable<V>> V maxUsingStreamAndLambda(Map<K, V> map) {
+
+        Optional<Entry<K, V>> maxEntry = map.entrySet()
+            .stream()
+            .max((Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue()
+                .compareTo(e2.getValue()));
+
+        return maxEntry.get()
+            .getValue();
+    }
+
+    public <K, V extends Comparable<V>> V maxUsingStreamAndMethodReference(Map<K, V> map) {
+
+        Optional<Entry<K, V>> maxEntry = map.entrySet()
+            .stream()
+            .max(Comparator.comparing(Map.Entry::getValue));
+
+        return maxEntry.get()
+            .getValue();
+    }
+
+    public static void main(String[] args) {
+
+        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
+
+        map.put(1, 3);
+        map.put(2, 4);
+        map.put(3, 5);
+        map.put(4, 6);
+        map.put(5, 7);
+        
+        MapMax mapMax = new MapMax();
+
+        System.out.println(mapMax.maxUsingIteration(map));
+        System.out.println(mapMax.maxUsingCollectionsMax(map));
+        System.out.println(mapMax.maxUsingCollectionsMaxAndLambda(map));
+        System.out.println(mapMax.maxUsingCollectionsMaxAndMethodReference(map));
+        System.out.println(mapMax.maxUsingStreamAndLambda(map));
+        System.out.println(mapMax.maxUsingStreamAndMethodReference(map));
+
+    }
+
+}

java-collections-maps/src/main/java/com/baeldung/sort/Employee.java

@@ -0,0 +1,60 @@
+package com.baeldung.sort;
+
+public class Employee implements Comparable<Employee> {
+
+    private Long id;
+    private String name;
+
+    public Employee(Long id, String name) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Employee employee = (Employee) o;
+
+        if (!id.equals(employee.id)) return false;
+        return name.equals(employee.name);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = id.hashCode();
+        result = 31 * result + name.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                '}';
+    }
+
+    @Override
+    public int compareTo(Employee employee) {
+        return (int)(this.id - employee.getId());
+    }
+}

java-collections-maps/src/main/java/com/baeldung/sort/SortHashMap.java

@@ -0,0 +1,104 @@
+package com.baeldung.sort;
+
+import com.google.common.base.Functions;
+import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class SortHashMap {
+
+    private static Map<String, Employee> map = new HashMap<>();
+
+    public static void main(String[] args) {
+
+        initialize();
+
+        treeMapSortByKey();
+
+        arrayListSortByValue();
+        arrayListSortByKey();
+
+        sortStream();
+
+        sortGuava();
+
+        addDuplicates();
+
+        treeSetByKey();
+        treeSetByValue();
+
+    }
+
+    private static void sortGuava() {
+        final Ordering naturalOrdering =
+        Ordering.natural().onResultOf(Functions.forMap(map, null));
+
+        System.out.println(ImmutableSortedMap.copyOf(map, naturalOrdering));
+    }
+
+    private static void sortStream() {
+        map.entrySet().stream()
+                .sorted(Map.Entry.<String, Employee>comparingByKey().reversed())
+                .forEach(System.out::println);
+
+        Map<String, Employee> result = map.entrySet().stream()
+                .sorted(Map.Entry.comparingByValue())
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
+                (oldValue, newValue) -> oldValue, LinkedHashMap::new));
+
+        result.entrySet().forEach(System.out::println);
+    }
+
+    private static void treeSetByValue() {
+        SortedSet<Employee> values = new TreeSet<>(map.values());
+        System.out.println(values);
+    }
+
+    private static void treeSetByKey() {
+        SortedSet<String> keysSet = new TreeSet<>(map.keySet());
+        System.out.println(keysSet);
+    }
+
+    private static void treeMapSortByKey() {
+        TreeMap<String, Employee> sorted = new TreeMap<>(map);
+        sorted.putAll(map);
+
+        sorted.entrySet().forEach(System.out::println);
+
+    }
+
+    private static void arrayListSortByValue() {
+        List<Employee> employeeById = new ArrayList<>(map.values());
+
+        Collections.sort(employeeById);
+
+        System.out.println(employeeById);
+    }
+
+    private static void arrayListSortByKey() {
+        List<String> employeeByKey = new ArrayList<>(map.keySet());
+        Collections.sort(employeeByKey);
+        System.out.println(employeeByKey);
+    }
+
+    private static void initialize() {
+        Employee employee1 = new Employee(1L, "Mher");
+        map.put(employee1.getName(), employee1);
+        Employee employee2 = new Employee(22L, "Annie");
+        map.put(employee2.getName(), employee2);
+        Employee employee3 = new Employee(8L, "John");
+        map.put(employee3.getName(), employee3);
+        Employee employee4 = new Employee(2L, "George");
+        map.put(employee4.getName(), employee4);
+    }
+
+    private static void addDuplicates() {
+        Employee employee5 = new Employee(1L, "Mher");
+        map.put(employee5.getName(), employee5);
+        Employee employee6 = new Employee(22L, "Annie");
+        map.put(employee6.getName(), employee6);
+    }
+}

java-collections-maps/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>