[BAEL-9550] - Moved articles and codes from core-java-collections module to java-collections-convversions and java-collections-maps module
This commit is contained in:
amit2103
@@ -4,37 +4,23 @@
|
||||
|
||||
### Relevant Articles:
|
||||
- [Immutable ArrayList in Java](http://www.baeldung.com/java-immutable-list)
|
||||
- [Converting between an Array and a List in Java](http://www.baeldung.com/convert-array-to-list-and-list-to-array)
|
||||
- [Converting between an Array and a Set in Java](http://www.baeldung.com/convert-array-to-set-and-set-to-array)
|
||||
- [Converting between a List and a Set in Java](http://www.baeldung.com/convert-list-to-set-and-set-to-list)
|
||||
- [Convert a Map to an Array, List or Set in Java](http://www.baeldung.com/convert-map-values-to-array-list-set)
|
||||
- [Guide to the Java ArrayList](http://www.baeldung.com/java-arraylist)
|
||||
- [Random List Element](http://www.baeldung.com/java-random-list-element)
|
||||
- [Java - Combine Multiple Collections](http://www.baeldung.com/java-combine-multiple-collections)
|
||||
- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
|
||||
- [Guide to the Guava BiMap](http://www.baeldung.com/guava-bimap)
|
||||
- [The Java HashMap Under the Hood](http://www.baeldung.com/java-hashmap)
|
||||
- [A Guide to LinkedHashMap in Java](http://www.baeldung.com/java-linked-hashmap)
|
||||
- [A Guide to TreeMap in Java](http://www.baeldung.com/java-treemap)
|
||||
- [Removing all nulls from a List in Java](http://www.baeldung.com/java-remove-nulls-from-list)
|
||||
- [Removing all duplicates from a List in Java](http://www.baeldung.com/java-remove-duplicates-from-list)
|
||||
- [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
|
||||
- [HashSet and TreeSet Comparison](http://www.baeldung.com/java-hashset-vs-treeset)
|
||||
- [Iterate over a Map in Java](http://www.baeldung.com/java-iterate-map)
|
||||
- [Collect a Java Stream to an Immutable Collection](http://www.baeldung.com/java-stream-immutable-collection)
|
||||
- [Converting a List to String in Java](http://www.baeldung.com/java-list-to-string)
|
||||
- [Introduction to the Java ArrayDeque](http://www.baeldung.com/java-array-deque)
|
||||
- [A Guide to HashSet in Java](http://www.baeldung.com/java-hashset)
|
||||
- [A Guide to TreeSet in Java](http://www.baeldung.com/java-tree-set)
|
||||
- [Java TreeMap vs HashMap](http://www.baeldung.com/java-treemap-vs-hashmap)
|
||||
- [How to TDD a List Implementation in Java](http://www.baeldung.com/java-test-driven-list)
|
||||
- [How to Store Duplicate Keys in a Map in Java?](http://www.baeldung.com/java-map-duplicate-keys)
|
||||
- [Getting the Size of an Iterable in Java](http://www.baeldung.com/java-iterable-size)
|
||||
- [Iterating Backward Through a List](http://www.baeldung.com/java-list-iterate-backwards)
|
||||
- [How to Filter a Collection in Java](http://www.baeldung.com/java-collection-filtering)
|
||||
- [Add Multiple Items to an Java ArrayList](http://www.baeldung.com/java-add-items-array-list)
|
||||
- [Remove the First Element from a List](http://www.baeldung.com/java-remove-first-element-from-list)
|
||||
- [How to Convert List to Map in Java](http://www.baeldung.com/java-list-to-map)
|
||||
- [Initializing HashSet at the Time of Construction](http://www.baeldung.com/java-initialize-hashset)
|
||||
- [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
|
||||
- [Fail-Safe Iterator vs Fail-Fast Iterator](http://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)
|
||||
@@ -47,12 +33,8 @@
|
||||
- [Remove All Occurrences of a Specific Value from a List](https://www.baeldung.com/java-remove-value-from-list)
|
||||
- [Thread Safe LIFO Data Structure Implementations](https://www.baeldung.com/java-lifo-thread-safe)
|
||||
- [Collections.emptyList() vs. New List Instance](https://www.baeldung.com/java-collections-emptylist-new-list)
|
||||
- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
|
||||
- [Differences Between Collection.clear() and Collection.removeAll()](https://www.baeldung.com/java-collection-clear-vs-removeall)
|
||||
- [Performance of contains() in a HashSet vs ArrayList](https://www.baeldung.com/java-hashset-arraylist-contains-performance)
|
||||
- [Get the Key for a Value from a Java Map](https://www.baeldung.com/java-map-key-from-value)
|
||||
- [Time Complexity of Java Collections](https://www.baeldung.com/java-collections-complexity)
|
||||
- [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)
|
||||
|
||||
@@ -14,22 +14,11 @@
|
||||
</parent>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>net.sourceforge.collections</groupId>
|
||||
<artifactId>collections-generic</artifactId>
|
||||
<version>${collections-generic.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-collections4</artifactId>
|
||||
<version>${commons-collections4.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.jayway.awaitility</groupId>
|
||||
<artifactId>awaitility</artifactId>
|
||||
<version>${avaitility.version}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-lang3</artifactId>
|
||||
@@ -67,12 +56,6 @@
|
||||
<artifactId>commons-exec</artifactId>
|
||||
<version>1.3</version>
|
||||
</dependency>
|
||||
|
||||
<dependency>
|
||||
<groupId>one.util</groupId>
|
||||
<artifactId>streamex</artifactId>
|
||||
<version>0.6.5</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<properties>
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
package com.baeldung.convertcollectiontoarraylist;
|
||||
|
||||
/**
|
||||
* This POJO is the element type of our collection. It has a deepCopy() method.
|
||||
*
|
||||
* @author chris
|
||||
*/
|
||||
public class Foo {
|
||||
|
||||
private int id;
|
||||
private String name;
|
||||
private Foo parent;
|
||||
|
||||
public Foo() {
|
||||
}
|
||||
|
||||
public Foo(int id, String name, Foo parent) {
|
||||
this.id = id;
|
||||
this.name = name;
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public void setId(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public Foo getParent() {
|
||||
return parent;
|
||||
}
|
||||
|
||||
public void setParent(Foo parent) {
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
public Foo deepCopy() {
|
||||
return new Foo(
|
||||
this.id, this.name, this.parent != null ? this.parent.deepCopy() : null);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
package com.baeldung.convertlisttomap;
|
||||
|
||||
public class Animal {
|
||||
private int id;
|
||||
private String name;
|
||||
|
||||
public Animal(int id, String name) {
|
||||
this.id = id;
|
||||
this.setName(name);
|
||||
}
|
||||
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public void setId(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
package com.baeldung.convertlisttomap;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
import org.apache.commons.collections4.MapUtils;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class ConvertListToMapService {
|
||||
|
||||
public Map<Integer, Animal> convertListBeforeJava8(List<Animal> list) {
|
||||
|
||||
Map<Integer, Animal> map = new HashMap<>();
|
||||
|
||||
for (Animal animal : list) {
|
||||
map.put(animal.getId(), animal);
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
public Map<Integer, Animal> convertListAfterJava8(List<Animal> list) {
|
||||
Map<Integer, Animal> map = list.stream().collect(Collectors.toMap(Animal::getId, animal -> animal));
|
||||
return map;
|
||||
}
|
||||
|
||||
public Map<Integer, Animal> convertListWithGuava(List<Animal> list) {
|
||||
|
||||
Map<Integer, Animal> map = Maps.uniqueIndex(list, Animal::getId);
|
||||
return map;
|
||||
}
|
||||
|
||||
public Map<Integer, Animal> convertListWithApacheCommons(List<Animal> list) {
|
||||
|
||||
Map<Integer, Animal> map = new HashMap<>();
|
||||
|
||||
MapUtils.populateMap(map, list, Animal::getId);
|
||||
|
||||
return map;
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
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;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
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);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,96 +0,0 @@
|
||||
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));
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
package com.baeldung.collection;
|
||||
|
||||
import java.util.ConcurrentModificationException;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import org.hamcrest.Matchers;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class WhenComparingTreeMapVsHashMap {
|
||||
|
||||
@Test
|
||||
public void whenInsertObjectsTreeMap_thenNaturalOrder() {
|
||||
Map<Integer, String> treemap = new TreeMap<>();
|
||||
treemap.put(3, "TreeMap");
|
||||
treemap.put(2, "vs");
|
||||
treemap.put(1, "HashMap");
|
||||
Assert.assertThat(treemap.keySet(), Matchers.contains(1, 2, 3));
|
||||
}
|
||||
|
||||
@Test(expected = NullPointerException.class)
|
||||
public void whenInsertNullInTreeMap_thenException() {
|
||||
Map<Integer, String> treemap = new TreeMap<>();
|
||||
treemap.put(null, "NullPointerException");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenInsertObjectsHashMap_thenRandomOrder() {
|
||||
Map<Integer, String> hashmap = new HashMap<>();
|
||||
hashmap.put(3, "TreeMap");
|
||||
hashmap.put(2, "vs");
|
||||
hashmap.put(1, "HashMap");
|
||||
Assert.assertThat(hashmap.keySet(), Matchers.containsInAnyOrder(1, 2, 3));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenInsertNullInHashMap_thenInsertsNull() {
|
||||
Map<Integer, String> hashmap = new HashMap<>();
|
||||
hashmap.put(null, null);
|
||||
Assert.assertNull(hashmap.get(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashMapAndTreeMap_whenputDuplicates_thenOnlyUnique() {
|
||||
Map<Integer, String> treeMap = new HashMap<>();
|
||||
treeMap.put(1, "Baeldung");
|
||||
treeMap.put(1, "Baeldung");
|
||||
|
||||
Assert.assertTrue(treeMap.size() == 1);
|
||||
|
||||
Map<Integer, String> treeMap2 = new TreeMap<>();
|
||||
treeMap2.put(1, "Baeldung");
|
||||
treeMap2.put(1, "Baeldung");
|
||||
|
||||
Assert.assertTrue(treeMap2.size() == 1);
|
||||
}
|
||||
}
|
||||
@@ -1,148 +0,0 @@
|
||||
package com.baeldung.convertcollectiontoarraylist;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import static java.util.stream.Collectors.toCollection;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author chris
|
||||
*/
|
||||
public class FooUnitTest {
|
||||
private static Collection<Foo> srcCollection = new HashSet<>();
|
||||
|
||||
public FooUnitTest() {
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void setUpClass() {
|
||||
int i = 0;
|
||||
Foo john = new Foo(i++, "John", null);
|
||||
Foo mary = new Foo(i++, "Mary", null);
|
||||
Foo sam = new Foo(i++, "Sam", john);
|
||||
Foo alice = new Foo(i++, "Alice", john);
|
||||
Foo buffy = new Foo(i++, "Buffy", sam);
|
||||
srcCollection.add(john);
|
||||
srcCollection.add(mary);
|
||||
srcCollection.add(sam);
|
||||
srcCollection.add(alice);
|
||||
srcCollection.add(buffy);
|
||||
|
||||
// make sure the collection isn't sorted accidentally
|
||||
assertFalse("Oops: source collection is already sorted!", isSorted(srcCollection));
|
||||
}
|
||||
|
||||
/**
|
||||
* Section 3. Using the ArrayList Constructor
|
||||
*/
|
||||
@Test
|
||||
public void whenUsingConstructor_thenVerifyShallowCopy() {
|
||||
ArrayList<Foo> newList = new ArrayList<>(srcCollection);
|
||||
verifyShallowCopy(srcCollection, newList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Section 4. Using the Streams API
|
||||
*/
|
||||
@Test
|
||||
public void whenUsingStream_thenVerifyShallowCopy() {
|
||||
ArrayList<Foo> newList = srcCollection.stream().collect(toCollection(ArrayList::new));
|
||||
|
||||
verifyShallowCopy(srcCollection, newList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Section 5. Deep Copy
|
||||
*/
|
||||
@Test
|
||||
public void whenUsingDeepCopy_thenVerifyDeepCopy() {
|
||||
ArrayList<Foo> newList = srcCollection.stream()
|
||||
.map(foo -> foo.deepCopy())
|
||||
.collect(toCollection(ArrayList::new));
|
||||
|
||||
verifyDeepCopy(srcCollection, newList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Section 6. Controlling the List Order
|
||||
*/
|
||||
@Test
|
||||
public void whenUsingSortedStream_thenVerifySortOrder() {
|
||||
ArrayList<Foo> newList = srcCollection.stream()
|
||||
.sorted(Comparator.comparing(Foo::getName))
|
||||
.collect(toCollection(ArrayList::new));
|
||||
|
||||
assertTrue("ArrayList is not sorted by name", isSorted(newList));
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify that the contents of the two collections are the same
|
||||
* @param a
|
||||
* @param b
|
||||
*/
|
||||
private void verifyShallowCopy(Collection a, Collection b) {
|
||||
assertEquals("Collections have different lengths", a.size(), b.size());
|
||||
Iterator<Foo> iterA = a.iterator();
|
||||
Iterator<Foo> iterB = b.iterator();
|
||||
while (iterA.hasNext()) {
|
||||
// use '==' to test instance identity
|
||||
assertTrue("Foo instances differ!", iterA.next() == iterB.next());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify that the contents of the two collections are the same
|
||||
* @param a
|
||||
* @param b
|
||||
*/
|
||||
private void verifyDeepCopy(Collection a, Collection b) {
|
||||
assertEquals("Collections have different lengths", a.size(), b.size());
|
||||
Iterator<Foo> iterA = a.iterator();
|
||||
Iterator<Foo> iterB = b.iterator();
|
||||
while (iterA.hasNext()) {
|
||||
Foo nextA = iterA.next();
|
||||
Foo nextB = iterB.next();
|
||||
// should not be same instance
|
||||
assertFalse("Foo instances are the same!", nextA == nextB);
|
||||
// but should have same content
|
||||
assertFalse("Foo instances have different content!", fooDiff(nextA, nextB));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return true if the contents of a and b differ. Test parent recursively
|
||||
* @param a
|
||||
* @param b
|
||||
* @return False if the two items are the same
|
||||
*/
|
||||
private boolean fooDiff(Foo a, Foo b) {
|
||||
if (a != null && b != null) {
|
||||
return a.getId() != b.getId()
|
||||
|| !a.getName().equals(b.getName())
|
||||
|| fooDiff(a.getParent(), b.getParent());
|
||||
}
|
||||
return !(a == null && b == null);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param c collection of Foo
|
||||
* @return true if the collection is sorted by name
|
||||
*/
|
||||
private static boolean isSorted(Collection<Foo> c) {
|
||||
String prevName = null;
|
||||
for (Foo foo : c) {
|
||||
if (prevName == null || foo.getName().compareTo(prevName) > 0) {
|
||||
prevName = foo.getName();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package com.baeldung.convertlisttomap;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.hamcrest.Matchers.containsInAnyOrder;
|
||||
|
||||
public class ConvertListToMapServiceUnitTest {
|
||||
List<Animal> list;
|
||||
|
||||
private ConvertListToMapService convertListService;
|
||||
|
||||
@Before
|
||||
public void init() {
|
||||
this.convertListService = new ConvertListToMapService();
|
||||
this.list = new ArrayList<>();
|
||||
|
||||
Animal cat = new Animal(1, "Cat");
|
||||
list.add(cat);
|
||||
Animal dog = new Animal(2, "Dog");
|
||||
list.add(dog);
|
||||
Animal pig = new Animal(3, "Pig");
|
||||
list.add(pig);
|
||||
Animal cow = new Animal(4, "Cow");
|
||||
list.add(cow);
|
||||
Animal goat = new Animal(5, "Goat");
|
||||
list.add(goat);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertBeforeJava8_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListBeforeJava8(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertAfterJava8_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListAfterJava8(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithGuava_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListWithGuava(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithApacheCommons_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListWithApacheCommons(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package com.baeldung.convertlisttomap;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.hamcrest.Matchers.hasItem;
|
||||
import static org.hamcrest.Matchers.hasSize;
|
||||
|
||||
public class ConvertListWithDiplicatedIdToMapServiceUnitTest {
|
||||
List<Animal> duplicatedIdList;
|
||||
|
||||
private ConvertListToMapService convertListService = new ConvertListToMapService();
|
||||
|
||||
@Before
|
||||
public void init() {
|
||||
|
||||
this.duplicatedIdList = new ArrayList<>();
|
||||
|
||||
Animal cat = new Animal(1, "Cat");
|
||||
duplicatedIdList.add(cat);
|
||||
Animal dog = new Animal(2, "Dog");
|
||||
duplicatedIdList.add(dog);
|
||||
Animal pig = new Animal(3, "Pig");
|
||||
duplicatedIdList.add(pig);
|
||||
Animal cow = new Animal(4, "Cow");
|
||||
duplicatedIdList.add(cow);
|
||||
Animal goat = new Animal(4, "Goat");
|
||||
duplicatedIdList.add(goat);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenADupIdList_whenConvertBeforeJava8_thenReturnMapWithRewrittenElement() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListBeforeJava8(duplicatedIdList);
|
||||
|
||||
assertThat(map.values(), hasSize(4));
|
||||
assertThat(map.values(), hasItem(duplicatedIdList.get(4)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenADupIdList_whenConvertWithApacheCommons_thenReturnMapWithRewrittenElement() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListWithApacheCommons(duplicatedIdList);
|
||||
|
||||
assertThat(map.values(), hasSize(4));
|
||||
assertThat(map.values(), hasItem(duplicatedIdList.get(4)));
|
||||
}
|
||||
|
||||
@Test(expected = IllegalStateException.class)
|
||||
public void givenADupIdList_whenConvertAfterJava8_thenException() {
|
||||
|
||||
convertListService.convertListAfterJava8(duplicatedIdList);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void givenADupIdList_whenConvertWithGuava_thenException() {
|
||||
|
||||
convertListService.convertListWithGuava(duplicatedIdList);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package com.baeldung.java.map;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.Map;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class KeyCheckUnitTest {
|
||||
|
||||
@Test
|
||||
public void whenKeyIsPresent_thenContainsKeyReturnsTrue() {
|
||||
Map<String, String> map = Collections.singletonMap("key", "value");
|
||||
|
||||
assertTrue(map.containsKey("key"));
|
||||
assertFalse(map.containsKey("missing"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenKeyHasNullValue_thenGetStillWorks() {
|
||||
Map<String, String> map = Collections.singletonMap("nothing", null);
|
||||
|
||||
assertTrue(map.containsKey("nothing"));
|
||||
assertNull(map.get("nothing"));
|
||||
}
|
||||
}
|
||||
@@ -1,124 +0,0 @@
|
||||
package com.baeldung.java.map;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.apache.commons.collections4.MultiMap;
|
||||
import org.apache.commons.collections4.MultiMapUtils;
|
||||
import org.apache.commons.collections4.MultiValuedMap;
|
||||
import org.apache.commons.collections4.map.MultiValueMap;
|
||||
import org.apache.commons.collections4.multimap.ArrayListValuedHashMap;
|
||||
import org.apache.commons.collections4.multimap.HashSetValuedHashMap;
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import com.google.common.collect.ArrayListMultimap;
|
||||
import com.google.common.collect.LinkedHashMultimap;
|
||||
import com.google.common.collect.Multimap;
|
||||
import com.google.common.collect.TreeMultimap;
|
||||
|
||||
public class MapMultipleValuesUnitTest {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(MapMultipleValuesUnitTest.class);
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenPuttingTwice_thenReturningFirstValue() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
assertThat(map.put("key1", "value1")).isEqualTo(null);
|
||||
assertThat(map.put("key1", "value2")).isEqualTo("value1");
|
||||
assertThat(map.get("key1")).isEqualTo("value2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCollectionAsValue_whenPuttingTwice_thenReturningCollection() {
|
||||
Map<String, List<String>> map = new HashMap<>();
|
||||
List<String> list = new ArrayList<>();
|
||||
map.put("key1", list);
|
||||
map.get("key1").add("value1");
|
||||
map.get("key1").add("value2");
|
||||
assertThat(map.get("key1").get(0)).isEqualTo("value1");
|
||||
assertThat(map.get("key1").get(1)).isEqualTo("value2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCollectionAsValueAndJava8_whenPuttingTwice_thenReturningCollection() {
|
||||
Map<String, List<String>> map = new HashMap<>();
|
||||
map.computeIfAbsent("key1", k -> new ArrayList<>()).add("value1");
|
||||
map.computeIfAbsent("key1", k -> new ArrayList<>()).add("value2");
|
||||
assertThat(map.get("key1").get(0)).isEqualTo("value1");
|
||||
assertThat(map.get("key1").get(1)).isEqualTo("value2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMultiValueMap_whenPuttingTwice_thenReturningValues() {
|
||||
MultiMap<String, String> map = new MultiValueMap<>();
|
||||
map.put("key1", "value1");
|
||||
map.put("key1", "value2");
|
||||
assertThat((Collection<String>) map.get("key1"))
|
||||
.contains("value1", "value2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayListValuedHashMap_whenPuttingDoubleValues_thenReturningAllValues() {
|
||||
MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
|
||||
map.put("key1", "value1");
|
||||
map.put("key1", "value2");
|
||||
map.put("key1", "value2");
|
||||
assertThat((Collection<String>) map.get("key1"))
|
||||
.containsExactly("value1", "value2", "value2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashSetValuedHashMap_whenPuttingTwiceTheSame_thenReturningOneValue() {
|
||||
MultiValuedMap<String, String> map = new HashSetValuedHashMap<>();
|
||||
map.put("key1", "value1");
|
||||
map.put("key1", "value1");
|
||||
assertThat((Collection<String>) map.get("key1"))
|
||||
.containsExactly("value1");
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void givenUnmodifiableMultiValuedMap_whenInserting_thenThrowingException() {
|
||||
MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
|
||||
map.put("key1", "value1");
|
||||
map.put("key1", "value2");
|
||||
MultiValuedMap<String, String> immutableMap =
|
||||
MultiMapUtils.unmodifiableMultiValuedMap(map);
|
||||
immutableMap.put("key1", "value3");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayListMultiMap_whenInserting_thenCorrectOutput() {
|
||||
Multimap<String, String> map = ArrayListMultimap.create();
|
||||
map.put("key1", "value2");
|
||||
map.put("key1", "value1");
|
||||
assertThat((Collection<String>) map.get("key1"))
|
||||
.containsExactly("value2", "value1");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMultiMap_whenInserting_thenReturningValuesInInsertionOrder() {
|
||||
Multimap<String, String> map = LinkedHashMultimap.create();
|
||||
map.put("key1", "value3");
|
||||
map.put("key1", "value1");
|
||||
map.put("key1", "value2");
|
||||
assertThat((Collection<String>) map.get("key1"))
|
||||
.containsExactly("value3", "value1", "value2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMultimap_whenInserting_thenReturningValuesInNaturalOrder() {
|
||||
Multimap<String, String> map = TreeMultimap.create();
|
||||
map.put("key1", "value3");
|
||||
map.put("key1", "value1");
|
||||
map.put("key1", "value2");
|
||||
assertThat((Collection<String>) map.get("key1"))
|
||||
.containsExactly("value1", "value2", "value3");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,336 +0,0 @@
|
||||
package com.baeldung.java.map;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class MapUnitTest {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(MapUnitTest.class);
|
||||
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenRetrievesKeyset_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
|
||||
assertEquals(2, keys.size());
|
||||
assertTrue(keys.contains("name"));
|
||||
assertTrue(keys.contains("type"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenRetrievesValues_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Collection<String> values = map.values();
|
||||
|
||||
assertEquals(2, values.size());
|
||||
assertTrue(values.contains("baeldung"));
|
||||
assertTrue(values.contains("blog"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenRetrievesEntries_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<Entry<String, String>> entries = map.entrySet();
|
||||
|
||||
assertEquals(2, entries.size());
|
||||
for (Entry<String, String> e : entries) {
|
||||
String key = e.getKey();
|
||||
String val = e.getValue();
|
||||
assertTrue(key.equals("name") || key.equals("type"));
|
||||
assertTrue(val.equals("baeldung") || val.equals("blog"));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenKeySet_whenChangeReflectsInMap_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
assertEquals(2, map.size());
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
|
||||
keys.remove("name");
|
||||
assertEquals(1, map.size());
|
||||
}
|
||||
|
||||
@Test(expected = ConcurrentModificationException.class)
|
||||
public void givenIterator_whenFailsFastOnModification_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
Iterator<String> it = keys.iterator();
|
||||
map.remove("type");
|
||||
while (it.hasNext()) {
|
||||
String key = it.next();
|
||||
}
|
||||
}
|
||||
|
||||
public void givenIterator_whenRemoveWorks_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
Iterator<String> it = keys.iterator();
|
||||
while (it.hasNext()) {
|
||||
it.next();
|
||||
it.remove();
|
||||
}
|
||||
assertEquals(0, map.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenHashCodeIsCalledOnPut_thenCorrect() {
|
||||
MyKey key = new MyKey(1, "name");
|
||||
Map<MyKey, String> map = new HashMap<>();
|
||||
map.put(key, "val");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenHashCodeIsCalledOnGet_thenCorrect() {
|
||||
MyKey key = new MyKey(1, "name");
|
||||
Map<MyKey, String> map = new HashMap<>();
|
||||
map.put(key, "val");
|
||||
map.get(key);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenGetWorks_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("key", "val");
|
||||
|
||||
String val = map.get("key");
|
||||
|
||||
assertEquals("val", val);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNewKey_whenPutReturnsNull_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String rtnVal = map.put("key1", "val1");
|
||||
|
||||
assertNull(rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUnmappedKey_whenGetReturnsNull_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String rtnVal = map.get("key1");
|
||||
|
||||
assertNull(rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullVal_whenPutReturnsNull_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String rtnVal = map.put("key1", null);
|
||||
|
||||
assertNull(rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullKeyAndVal_whenAccepts_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
map.put(null, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullVal_whenRetrieves_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("key", null);
|
||||
|
||||
String val = map.get("key");
|
||||
|
||||
assertNull(val);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenContainsDistinguishesNullValues_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String val1 = map.get("key");
|
||||
boolean valPresent = map.containsKey("key");
|
||||
|
||||
assertNull(val1);
|
||||
assertFalse(valPresent);
|
||||
|
||||
map.put("key", null);
|
||||
String val = map.get("key");
|
||||
valPresent = map.containsKey("key");
|
||||
|
||||
assertNull(val);
|
||||
assertTrue(valPresent);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenPutReturnsPrevValue_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("key1", "val1");
|
||||
String rtnVal = map.put("key1", "val2");
|
||||
|
||||
assertEquals("val1", rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCallsEqualsOnCollision_thenCorrect() {
|
||||
HashMap<MyKey, String> map = new HashMap<>();
|
||||
MyKey k1 = new MyKey(1, "firstKey");
|
||||
MyKey k2 = new MyKey(2, "secondKey");
|
||||
MyKey k3 = new MyKey(2, "thirdKey");
|
||||
|
||||
LOG.debug("storing value for k1");
|
||||
map.put(k1, "firstValue");
|
||||
|
||||
LOG.debug("storing value for k2");
|
||||
map.put(k2, "secondValue");
|
||||
|
||||
LOG.debug("storing value for k3");
|
||||
map.put(k3, "thirdValue");
|
||||
|
||||
LOG.debug("retrieving value for k1");
|
||||
String v1 = map.get(k1);
|
||||
|
||||
LOG.debug("retrieving value for k2");
|
||||
String v2 = map.get(k2);
|
||||
|
||||
LOG.debug("retrieving value for k3");
|
||||
String v3 = map.get(k3);
|
||||
|
||||
assertEquals("firstValue", v1);
|
||||
assertEquals("secondValue", v2);
|
||||
assertEquals("thirdValue", v3);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMap_whenGetsOrderedKeyset_thenCorrect() {
|
||||
LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
|
||||
map.put(1, null);
|
||||
map.put(2, null);
|
||||
map.put(3, null);
|
||||
map.put(4, null);
|
||||
map.put(5, null);
|
||||
Set<Integer> keys = map.keySet();
|
||||
Integer[] arr = keys.toArray(new Integer[0]);
|
||||
for (int i = 0; i < arr.length; i++) {
|
||||
assertEquals(new Integer(i + 1), arr[i]);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMap_whenAccessOrderWorks_thenCorrect() {
|
||||
LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16, .75f, true);
|
||||
map.put(1, null);
|
||||
map.put(2, null);
|
||||
map.put(3, null);
|
||||
map.put(4, null);
|
||||
map.put(5, null);
|
||||
Set<Integer> keys = map.keySet();
|
||||
assertEquals("[1, 2, 3, 4, 5]", keys.toString());
|
||||
map.get(4);
|
||||
assertEquals("[1, 2, 3, 5, 4]", keys.toString());
|
||||
map.get(1);
|
||||
assertEquals("[2, 3, 5, 4, 1]", keys.toString());
|
||||
map.get(3);
|
||||
assertEquals("[2, 5, 4, 1, 3]", keys.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMap_whenRemovesEldestEntry_thenCorrect() {
|
||||
LinkedHashMap<Integer, String> map = new MyLinkedHashMap<>(16, .75f, true);
|
||||
map.put(1, null);
|
||||
map.put(2, null);
|
||||
map.put(3, null);
|
||||
map.put(4, null);
|
||||
map.put(5, null);
|
||||
Set<Integer> keys = map.keySet();
|
||||
assertEquals("[1, 2, 3, 4, 5]", keys.toString());
|
||||
map.put(6, null);
|
||||
assertEquals("[2, 3, 4, 5, 6]", keys.toString());
|
||||
map.put(7, null);
|
||||
assertEquals("[3, 4, 5, 6, 7]", keys.toString());
|
||||
map.put(8, null);
|
||||
assertEquals("[4, 5, 6, 7, 8]", keys.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenOrdersEntriesNaturally_thenCorrect() {
|
||||
TreeMap<Integer, String> map = new TreeMap<>();
|
||||
map.put(3, "val");
|
||||
map.put(2, "val");
|
||||
map.put(1, "val");
|
||||
map.put(5, "val");
|
||||
map.put(4, "val");
|
||||
assertEquals("[1, 2, 3, 4, 5]", map.keySet().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenOrdersEntriesNaturally_thenCorrect2() {
|
||||
TreeMap<String, String> map = new TreeMap<>();
|
||||
map.put("c", "val");
|
||||
map.put("b", "val");
|
||||
map.put("a", "val");
|
||||
map.put("e", "val");
|
||||
map.put("d", "val");
|
||||
|
||||
assertEquals("[a, b, c, d, e]", map.keySet().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenOrdersEntriesByComparator_thenCorrect() {
|
||||
TreeMap<Integer, String> map = new TreeMap<>(Comparator.reverseOrder());
|
||||
map.put(3, "val");
|
||||
map.put(2, "val");
|
||||
map.put(1, "val");
|
||||
map.put(5, "val");
|
||||
map.put(4, "val");
|
||||
|
||||
assertEquals("[5, 4, 3, 2, 1]", map.keySet().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenPerformsQueries_thenCorrect() {
|
||||
TreeMap<Integer, String> map = new TreeMap<>();
|
||||
map.put(3, "val");
|
||||
map.put(2, "val");
|
||||
map.put(1, "val");
|
||||
map.put(5, "val");
|
||||
map.put(4, "val");
|
||||
|
||||
Integer highestKey = map.lastKey();
|
||||
Integer lowestKey = map.firstKey();
|
||||
Set<Integer> keysLessThan3 = map.headMap(3).keySet();
|
||||
Set<Integer> keysGreaterThanEqTo3 = map.tailMap(3).keySet();
|
||||
|
||||
assertEquals(new Integer(5), highestKey);
|
||||
assertEquals(new Integer(1), lowestKey);
|
||||
assertEquals("[1, 2]", keysLessThan3.toString());
|
||||
assertEquals("[3, 4, 5]", keysGreaterThanEqTo3.toString());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package com.baeldung.java.map;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.apache.commons.collections4.BidiMap;
|
||||
import org.apache.commons.collections4.bidimap.DualHashBidiMap;
|
||||
import org.junit.Test;
|
||||
|
||||
import com.google.common.collect.HashBiMap;
|
||||
|
||||
/**
|
||||
* @author swpraman
|
||||
*
|
||||
*/
|
||||
public class MapUtilUnitTest {
|
||||
|
||||
|
||||
@Test
|
||||
public void whenUsingImperativeWayForSingleKey_shouldReturnSingleKey() {
|
||||
Map<String, String> capitalCountryMap = new HashMap<>();
|
||||
capitalCountryMap.put("Tokyo", "Japan");
|
||||
capitalCountryMap.put("New Delhi", "India");
|
||||
assertEquals("New Delhi", MapUtil.getKey(capitalCountryMap, "India"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingImperativeWayForAllKeys_shouldReturnAllKeys() {
|
||||
Map<String, String> capitalCountryMap = new HashMap<>();
|
||||
capitalCountryMap.put("Tokyo", "Japan");
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
capitalCountryMap.put("Cape Town", "South Africa");
|
||||
capitalCountryMap.put("Pretoria", "South Africa");
|
||||
capitalCountryMap.put("Bloemfontein", "South Africa");
|
||||
|
||||
assertEquals(new HashSet<String>(Arrays.asList(
|
||||
new String[] {"Cape Town", "Pretoria", "Bloemfontein"})),
|
||||
MapUtil.getKeys(capitalCountryMap, "South Africa"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingFunctionalWayForSingleKey_shouldReturnSingleKey() {
|
||||
Map<String, String> capitalCountryMap = new HashMap<>();
|
||||
capitalCountryMap.put("Tokyo", "Japan");
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
assertEquals("Berlin", MapUtil.keys(capitalCountryMap, "Germany").findFirst().get());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingFunctionalWayForAllKeys_shouldReturnAllKeys() {
|
||||
Map<String, String> capitalCountryMap = new HashMap<>();
|
||||
capitalCountryMap.put("Tokyo", "Japan");
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
capitalCountryMap.put("Cape Town", "South Africa");
|
||||
capitalCountryMap.put("Pretoria", "South Africa");
|
||||
capitalCountryMap.put("Bloemfontein", "South Africa");
|
||||
assertEquals(new HashSet<String>(Arrays.asList(
|
||||
new String[] {"Cape Town", "Pretoria", "Bloemfontein"})),
|
||||
MapUtil.keys(capitalCountryMap, "South Africa").collect(Collectors.toSet()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingBidiMap_shouldReturnKey() {
|
||||
BidiMap<String, String> capitalCountryMap = new DualHashBidiMap<String, String>();
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
capitalCountryMap.put("Cape Town", "South Africa");
|
||||
assertEquals("Berlin", capitalCountryMap.getKey("Germany"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingBidiMapAddDuplicateValue_shouldRemoveOldEntry() {
|
||||
BidiMap<String, String> capitalCountryMap = new DualHashBidiMap<String, String>();
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
capitalCountryMap.put("Cape Town", "South Africa");
|
||||
capitalCountryMap.put("Pretoria", "South Africa");
|
||||
assertEquals("Pretoria", capitalCountryMap.getKey("South Africa"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingBiMap_shouldReturnKey() {
|
||||
HashBiMap<String, String> capitalCountryMap = HashBiMap.create();
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
capitalCountryMap.put("Cape Town", "South Africa");
|
||||
assertEquals("Berlin", capitalCountryMap.inverse().get("Germany"));
|
||||
}
|
||||
|
||||
@Test(expected=IllegalArgumentException.class)
|
||||
public void whenUsingBiMapAddDuplicateValue_shouldThrowException() {
|
||||
HashBiMap<String, String> capitalCountryMap = HashBiMap.create();
|
||||
capitalCountryMap.put("Berlin", "Germany");
|
||||
capitalCountryMap.put("Cape Town", "South Africa");
|
||||
capitalCountryMap.put("Pretoria", "South Africa");
|
||||
assertEquals("Berlin", capitalCountryMap.inverse().get("Germany"));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
package com.baeldung.java.map.initialize;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class MapInitializerUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenStaticMap_whenUpdated_thenCorrect() {
|
||||
|
||||
MapInitializer.articleMapOne.put("NewArticle1", "Convert array to List");
|
||||
|
||||
assertEquals(MapInitializer.articleMapOne.get("NewArticle1"), "Convert array to List");
|
||||
|
||||
}
|
||||
|
||||
@Test(expected=UnsupportedOperationException.class)
|
||||
public void givenSingleTonMap_whenEntriesAdded_throwsException() {
|
||||
|
||||
Map<String, String> map = MapInitializer.createSingletonMap();
|
||||
map.put("username2", "password2");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
package com.baeldung.map.util;
|
||||
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
public class MapMaxUnitTest {
|
||||
|
||||
Map<Integer, Integer> map = null;
|
||||
MapMax mapMax = null;
|
||||
|
||||
|
||||
@Before
|
||||
public void setupTestData() {
|
||||
map = new HashMap<Integer, Integer>();
|
||||
map.put(23, 12);
|
||||
map.put(46, 24);
|
||||
map.put(27, 38);
|
||||
mapMax = new MapMax();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMap_whenIterated_thenReturnMaxValue() {
|
||||
assertEquals(new Integer(38), mapMax.maxUsingIteration(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMap_whenUsingCollectionsMax_thenReturnMaxValue() {
|
||||
assertEquals(new Integer(38), mapMax.maxUsingCollectionsMax(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMap_whenUsingCollectionsMaxAndLambda_thenReturnMaxValue() {
|
||||
assertEquals(new Integer(38), mapMax.maxUsingCollectionsMaxAndLambda(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMap_whenUsingCollectionsMaxAndMethodReference_thenReturnMaxValue() {
|
||||
assertEquals(new Integer(38), mapMax.maxUsingCollectionsMaxAndMethodReference(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMap_whenUsingStreamAndLambda_thenReturnMaxValue() {
|
||||
assertEquals(new Integer(38), mapMax.maxUsingStreamAndLambda(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMap_whenUsingStreamAndMethodReference_thenReturnMaxValue() {
|
||||
assertEquals(new Integer(38), mapMax.maxUsingStreamAndMethodReference (map));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
package com.baeldung.weakhashmap;
|
||||
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.WeakHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static com.jayway.awaitility.Awaitility.await;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class WeakHashMapUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenWeakHashMap_whenCacheValueThatHasNoReferenceToIt_GCShouldReclaimThatObject() {
|
||||
//given
|
||||
WeakHashMap<UniqueImageName, BigImage> map = new WeakHashMap<>();
|
||||
BigImage bigImage = new BigImage("image_id");
|
||||
UniqueImageName imageName = new UniqueImageName("name_of_big_image");
|
||||
|
||||
map.put(imageName, bigImage);
|
||||
assertTrue(map.containsKey(imageName));
|
||||
|
||||
//when big image key is not reference anywhere
|
||||
imageName = null;
|
||||
System.gc();
|
||||
|
||||
//then GC will finally reclaim that object
|
||||
await().atMost(10, TimeUnit.SECONDS).until(map::isEmpty);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenWeakHashMap_whenCacheValueThatHasNoReferenceToIt_GCShouldReclaimThatObjectButLeaveReferencedObject() {
|
||||
//given
|
||||
WeakHashMap<UniqueImageName, BigImage> map = new WeakHashMap<>();
|
||||
BigImage bigImageFirst = new BigImage("foo");
|
||||
UniqueImageName imageNameFirst = new UniqueImageName("name_of_big_image");
|
||||
|
||||
BigImage bigImageSecond = new BigImage("foo_2");
|
||||
UniqueImageName imageNameSecond = new UniqueImageName("name_of_big_image_2");
|
||||
|
||||
map.put(imageNameFirst, bigImageFirst);
|
||||
map.put(imageNameSecond, bigImageSecond);
|
||||
assertTrue(map.containsKey(imageNameFirst));
|
||||
assertTrue(map.containsKey(imageNameSecond));
|
||||
|
||||
//when
|
||||
imageNameFirst = null;
|
||||
System.gc();
|
||||
|
||||
//then
|
||||
await().atMost(10, TimeUnit.SECONDS).until(() -> map.size() == 1);
|
||||
await().atMost(10, TimeUnit.SECONDS).until(() -> map.containsKey(imageNameSecond));
|
||||
}
|
||||
|
||||
|
||||
class BigImage {
|
||||
public final String imageId;
|
||||
|
||||
BigImage(String imageId) {
|
||||
this.imageId = imageId;
|
||||
}
|
||||
}
|
||||
|
||||
class UniqueImageName {
|
||||
public final String imageName;
|
||||
|
||||
UniqueImageName(String imageName) {
|
||||
this.imageName = imageName;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,187 +0,0 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.apache.commons.collections4.CollectionUtils;
|
||||
import org.apache.commons.lang3.ArrayUtils;
|
||||
import org.junit.Test;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Sets;
|
||||
import com.google.common.primitives.Ints;
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public class JavaCollectionConversionUnitTest {
|
||||
|
||||
// List -> array; array -> List
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenArrayConvertedToList_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final List<Integer> targetList = Arrays.asList(sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenListConvertedToArray_thenCorrect() {
|
||||
final List<Integer> sourceList = Arrays.asList(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceList.toArray(new Integer[sourceList.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenArrayConvertedToList_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final List<Integer> targetList = Lists.newArrayList(sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenListConvertedToArray_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
final int[] targetArray = Ints.toArray(sourceList);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCommonsCollections_whenArrayConvertedToList_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final List<Integer> targetList = new ArrayList<>(6);
|
||||
CollectionUtils.addAll(targetList, sourceArray);
|
||||
}
|
||||
|
||||
// Set -> array; array -> Set
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJavaV1_whenArrayConvertedToSet_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final Set<Integer> targetSet = new HashSet<Integer>(Arrays.asList(sourceArray));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJavaV2_whenArrayConvertedToSet_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final Set<Integer> targetSet = new HashSet<Integer>();
|
||||
Collections.addAll(targetSet, sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenSetConvertedToArray_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceSet.toArray(new Integer[sourceSet.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenArrayConvertedToSet_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final Set<Integer> targetSet = Sets.newHashSet(sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenSetConvertedToArray_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final int[] targetArray = Ints.toArray(sourceSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCommonsCollections_whenArrayConvertedToSet_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final Set<Integer> targetSet = new HashSet<>(6);
|
||||
CollectionUtils.addAll(targetSet, sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCommonsCollections_whenSetConvertedToArray_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceSet.toArray(new Integer[sourceSet.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCommonsCollections_whenSetConvertedToArrayOfPrimitives_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceSet.toArray(new Integer[sourceSet.size()]);
|
||||
final int[] primitiveTargetArray = ArrayUtils.toPrimitive(targetArray);
|
||||
}
|
||||
|
||||
// Set -> List; List -> Set
|
||||
|
||||
public final void givenUsingCoreJava_whenSetConvertedToList_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final List<Integer> targetList = new ArrayList<>(sourceSet);
|
||||
}
|
||||
|
||||
public final void givenUsingCoreJava_whenListConvertedToSet_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
final Set<Integer> targetSet = new HashSet<>(sourceList);
|
||||
}
|
||||
|
||||
public final void givenUsingGuava_whenSetConvertedToList_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final List<Integer> targetList = Lists.newArrayList(sourceSet);
|
||||
}
|
||||
|
||||
public final void givenUsingGuava_whenListConvertedToSet_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
final Set<Integer> targetSet = Sets.newHashSet(sourceList);
|
||||
}
|
||||
|
||||
public final void givenUsingCommonsCollections_whenListConvertedToSet_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
|
||||
final Set<Integer> targetSet = new HashSet<>(6);
|
||||
CollectionUtils.addAll(targetSet, sourceList);
|
||||
}
|
||||
|
||||
public final void givenUsingCommonsCollections_whenSetConvertedToList_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
|
||||
final List<Integer> targetList = new ArrayList<>(6);
|
||||
CollectionUtils.addAll(targetList, sourceSet);
|
||||
}
|
||||
|
||||
// Map (values) -> Array, List, Set
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenMapValuesConvertedToArray_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final Collection<String> values = sourceMap.values();
|
||||
final String[] targetArray = values.toArray(new String[values.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenMapValuesConvertedToList_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final List<String> targetList = new ArrayList<>(sourceMap.values());
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenMapValuesConvertedToList_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final List<String> targetList = Lists.newArrayList(sourceMap.values());
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenMapValuesConvertedToSet_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final Set<String> targetSet = new HashSet<>(sourceMap.values());
|
||||
}
|
||||
|
||||
// UTIL
|
||||
|
||||
private final Map<Integer, String> createMap() {
|
||||
final Map<Integer, String> sourceMap = new HashMap<>(3);
|
||||
sourceMap.put(0, "zero");
|
||||
sourceMap.put(1, "one");
|
||||
sourceMap.put(2, "two");
|
||||
return sourceMap;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package org.baeldung.java.lists;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
import org.junit.Test;
|
||||
|
||||
public class ListToSTring {
|
||||
|
||||
@Test
|
||||
public void whenListToString_thenPrintDefault() {
|
||||
List<Integer> intLIst = Arrays.asList(1, 2, 3);
|
||||
System.out.println(intLIst);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCollectorsJoining_thenPrintCustom() {
|
||||
List<Integer> intList = Arrays.asList(1, 2, 3);
|
||||
System.out.println(intList.stream()
|
||||
.map(n -> String.valueOf(n))
|
||||
.collect(Collectors.joining("-", "{", "}")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenStringUtilsJoin_thenPrintCustom() {
|
||||
List<Integer> intList = Arrays.asList(1, 2, 3);
|
||||
System.out.println(StringUtils.join(intList, "|"));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user