This doesn't compile:
Map<String, Object> map = new HashMap<String, Object>();
HashMultiset<Map<String, Object>> n1Properties = HashMultiset.create(map);
None of the overloaded create methods accepts a Map. But you can use the addAll method to add the Map converted to a Collection.
import com.google.common.collect.HashMultiset;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class SO {
public static void main(String args[]) {
Map<String, Object> map = new HashMap<>();
map.put("foo", "FOO");
map.put("bar", "BAR");
HashMultiset<Map<String, Object>> n1Properties = HashMultiset.create();
n1Properties.addAll(Collections.singleton(map));
System.out.println(n1Properties);
}
}
Output:
[{bar=BAR, foo=FOO}]
Related
Trying to sort HashMap of <String,Double> without using treeMap or other method. Need the code to pass a hashMap and return a sorted hashMap in the fastest time. What am I doing wrong with the string Comparator. Please look and advise. Thank you very much!!!
/// Here's the main
package Sort_String_Double_without_TreeMap;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class Main {
public static void main(String[] args) throws InterruptedException {
Map<String, Double> outGoing = new HashMap<>();
outGoing.put("J", -5.0);
outGoing.put("X", 0.7);
outGoing.put("C", 0.0);
outGoing.put("D", 80.0);
outGoing.put("A", 80.0);
System.out.println("---UNSORTED---");
System.out.println(outGoing);
TimeUnit.SECONDS.sleep(1);
Helper_SorterClass sorter = new Helper_SorterClass ();
System.out.println("---SORTED---");
System.out.println();
System.out.println("SIZE= " + sorter.SortHashMapKey(outGoing).size());
System.out.println(sorter.SortHashMapKey(outGoing));
}
}
And Here's the other class...
/// Here's the helper class
package Sort_String_Double_without_TreeMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Helper_SorterClass {
public Map<String, Double> SortHashMapKey(Map<String, Double> unsortedMap) {
List<String> list = new ArrayList(unsortedMap.keySet());
Collections.sort(list, new Comparator<String>() {
#Override
public int compare(String o1, String o2) {
return String.valueOf(o1).compareTo(String.valueOf(o2));
}
});
Map<String, Double> sortedMap = new HashMap<>();
for (String keys : list) {
sortedMap.put(keys, unsortedMap.get(keys));
}
return sortedMap;
}
}
Unfortunately getting wrong output.
run:
---UNSORTED---
{A=80.0, C=0.0, D=80.0, X=0.7, J=-5.0}
---SORTED---
SIZE= 5
{A=80.0, C=0.0, D=80.0, X=0.7, J=-5.0}
BUILD SUCCESSFUL (total time: 1 second)
Map<String, Double> sortedMap = new HashMap<>();
for (String keys : list) {
sortedMap.put(keys, unsortedMap.get(keys));
}
you should use LinkedHashMap instead of HashMap as below:
Map<String, Double> sortedMap = new LinkedHashMap<>();
for (String keys : list) {
sortedMap.put(keys, unsortedMap.get(keys));
}
HashMap doesn't maintain insertion order. So once you put the entries in a new HashMap() after comparing, it will again give unsorted result when you iterate over the new map. But if you use a LinkedHashMap, it will maintain insertion order while iterating.
I was trying to get the response headers, which are in the form of MultivaluedMap<String, Object>.
The object is in the form of List<String>.
I want to store it in a Map<String, List<String>>.
Is there any direct way to do this?
To convert MultivaluedMap to Map<String,List<String>> you can do this :
First create a method that convert List<Object> to List<String> (MultivaluedMap::get return a List<Object>) and return a Map<String,List<String>> (to keep trace of key)
public static Map<String,List of String> convertListObjectToListofString(String k, List<Object> object) {
List<String> list = object.stream()
.flatMap(obj -> new ArrayList<String>((Collection<String>)obj).stream())
.collect(Collectors.toList());
Map<String, List<String>> map = new HashMap<String, List<String>>();
map.put(k, list);
return map;
}
After that you can stream you MultivaluedMap (.entrySet().stream()) and convert it to Map<String, List> using convertListObjectToListofString and re-stream the maps returned to collect all result in one map ( .flatMap(eS ->convertListObjectToListofString(eS.getKey(), eS.getValue()).entrySet().stream())
.collect(Collectors.toMap(eS->eS.getKey(), eS -> eS.getValue()));
)
And here all the code :
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
public class MapObjectToStringList {
public static void main(String[] args) {
List<String> list1 = new ArrayList<>(Arrays.asList("a","b","c"));
List<String> list2 = new ArrayList<>(Arrays.asList("d","e","f"));
List<String> list3 = new ArrayList<>(Arrays.asList("g","h","i"));
List<String> list4 = new ArrayList<>(Arrays.asList("j","k","l"));
MultivaluedMap<String, Object> map = new MultivaluedHashMap<String, Object>();
map.add("aa", list1);
map.add("bb", list2);
map.add("cc", list3);
map.add("dd", list4);
Map<String, List<String>> collect = map.entrySet().stream()
.flatMap(eS ->convertListObjectToListofString(eS.getKey(), eS.getValue()).entrySet().stream())
.collect(Collectors.toMap(eS->eS.getKey(), eS -> eS.getValue()));
System.out.println(collect);
}
public static Map<String,List<String>> convertListObjectToListofString(String k, List<Object> object) {
List<String> list = object.stream()
.flatMap(obj -> new ArrayList<String>((Collection<String>)obj).stream())
.collect(Collectors.toList());;
Map<String, List<String>> map = new HashMap<String, List<String>>();
map.put(k, list);
return map;
}
}
PS:
This code run with java 8 and I add javax.ws.rs-api-2.0.jar to my project
I have a List of objects. Some objects are Map<String, String> and others are Map<String, List<String>> types. I need to group those in to different lists.
Please tell me If there any methods to handle these challenge.
This looked like a fun code challenge. I wrote a small java class demonstrating how you can use 'instanceof' operator to split out these values into separate collections.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
class Scratch {
public static void main(String[] args) {
// test data
List<Map<String, ?>> mixed = new ArrayList<>();
Map<String, String> strings = new HashMap<>();
strings.put("x", "y");
Map<String, List<String>> lists = new HashMap<>();
List<String> list = new ArrayList<>();
list.add("z");
lists.put("w", list);
mixed.add(strings);
mixed.add(lists);
// split out data
Map<String, String> onlyStrings = new HashMap<>();
Map<String, List<String>> onlyLists = new HashMap<>();
for (Map<String, ?> item : mixed) {
for (Map.Entry<String, ?> entry : item.entrySet()) {
Object value = entry.getValue();
if (value instanceof String) {
onlyStrings.put(entry.getKey(), (String)entry.getValue());
} else if (value instanceof List) {
onlyLists.put(entry.getKey(), (List<String>)entry.getValue());
}
}
}
// print out
System.out.println("---Strings---");
for (Map.Entry<String, String> entry : onlyStrings.entrySet()) {
System.out.println(entry);
}
System.out.println("---Lists---");
for (Map.Entry<String, List<String>> entry : onlyLists.entrySet()) {
System.out.println(entry);
}
}
}
Output
---Strings---
x=y
---Lists---
w=[z]
Hope it helps and is what you are after
i am just synchronizing the HashMap using Collections.synchronizedMap(map); then adding values to the map as shown below. And in second scenario i have added keys and values to the map then i am doing synchronization to map object. But i did not find any difference in the output.
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class SyncHashMap {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map = Collections.synchronizedMap(map);
map.put(10, "ten");
map.put(20, "twenty");
map.put(30, "thirty");
map.put(40, "forty");
map.put(50, "fifty");
System.out.println(map);
}
}
Output:
{50=fifty, 20=twenty, 40=forty, 10=ten, 30=thirty}
In another scenario:
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class SyncHashMap {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(10, "ten");
map.put(20, "twenty");
map.put(30, "thirty");
map.put(40, "forty");
map.put(50, "fifty");
map = Collections.synchronizedMap(map);
System.out.println(map);
}
}
Output:
{50=fifty, 20=twenty, 40=forty, 10=ten, 30=thirty}
Is there any difference in between these outputs. Otherwise any particular way to find difference in synchronizedMap method while using. Need some clarification.
I'm having trouble applying sorting mechanism through my application.
Reason was sometimes sort are not accurate and also the comparator thing in java still not clear for me, but i have used sort here and there.
Now, current problem is as follows.
I have
HashMap<String, ModelX.ContactModel> unsortedModelContacts =
new HashMap<String,ModelX.ContactModel>(contacts.size());
After that I fached
contactlist and using for loop I have put the values as follows:
unsortedModelContacts.put(stringvalue, modelContact);
//object having name , and other details
How can I sort the unsortedModelContacts sorting modelContact.getName property?
If your map's key is different from the name field then you can consider using this approach. Writing a separate comparator
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import sample.ModelX.ContactModel;
public class SortMapSample {
public static void main(String[] args) throws Exception {
Map<String, ModelX.ContactModel> unsortedModelContacts = new HashMap<String,ModelX.ContactModel>(10);
unsortedModelContacts.put("1", new ModelX.ContactModel("James"));
unsortedModelContacts.put("2", new ModelX.ContactModel("Mary"));
unsortedModelContacts.put("3", new ModelX.ContactModel("John"));
unsortedModelContacts.put("4", new ModelX.ContactModel("Amanda"));
unsortedModelContacts.put("5", new ModelX.ContactModel("Charles"));
System.out.println(sortMap(unsortedModelContacts));
}
private static Map<String, ModelX.ContactModel> sortMap(
Map<String, ModelX.ContactModel> unsortedMap) {
List<Entry<String, ModelX.ContactModel>> list = new LinkedList<Entry<String, ModelX.ContactModel>>(
unsortedMap.entrySet());
Collections.sort(list,
new Comparator<Entry<String, ModelX.ContactModel>>() {
#Override
public int compare(Entry<String, ContactModel> o1,
Entry<String, ContactModel> o2) {
return o1.getValue().getName().compareTo(o2.getValue().getName());
}
});
Map<String, ModelX.ContactModel> sortedMap = new LinkedHashMap<String, ModelX.ContactModel>();
for(Entry<String, ModelX.ContactModel> item : list){
sortedMap.put(item.getKey(), item.getValue());
}
return sortedMap;
}
}
SortedMap<String,ModelX.ContactModel> sortedModelContacts = new TreeMap<>();
for( ModelX.ContactModel modelContact: contactlist ){ // same list as before
sortedModelContacts.put( modelContact.getName(), modelContact);
}
You can now access entries of this map in sort order of the name property.
Note: this assumes that names are unique. If this isn't true, you'll have to use a multimap or
Map<String,ModelX.Set<ContactModel>>
and modify the put and other accesses accordingly.