Develop Reference

Sort <String,Double> HashMap using comparator and without TreeMap

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.

How to create a Guava HashMultiset from a Map<String, Object>

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}]

Collection.sort using anonymous class Comparator

I did not find needed information, so I decided to create a new question.
I have a little test app where I want to sort my Map by Values. But I can't understand why I can't do it in the following way:
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
public class Test {
public int test(int [] array) {
Map<Integer, Integer> map = new HashMap<>();
map.put(1,4);
map.put(2,3);
map.put(5,1);
map.put(7,0);
map.put(4,4);
map.put(9,1);
Collections.sort(map.entrySet(), new Comparator<Map.Entry<Integer, Integer>>() {
#Override
public int compare(Map.Entry<Integer, Integer> t, Map.Entry<Integer, Integer> t1) {
return t.getValue().compareTo(t1.getValue());
}
});
for(Map.Entry<Integer, Integer> entry : map.entrySet()){
sum += entry.getValue();
}
return sum;
}
}
and Main class:
public class Main {
public static void main(String[] args) {
Test test = new Test();
System.out.println(test.test(arr));
}
}
This app shoud return 14 in this case. But I have this message on
Collections.sort(...) part:
sort (java.util.List, java.util.Comparator) in Collections cannot be applied to
(java.util.Set>,
anonymous
java.util.Comparator>)
  reason: no instance(s) of type variable(s) T exist so that
Set> conforms to List
but if I change it to Collections.min(...) or Collections.max(...):
Collections.min(map.entrySet(), new Comparator<Map.Entry<Integer, Integer>>() {
#Override
public int compare(Map.Entry<Integer, Integer> t, Map.Entry<Integer, Integer> t1) {
return t.getValue().compareTo(t1.getValue());
}
});
there will be no issues.

Java Map can't be sorted by value. But you can create a list from Map.entrySet() or maybe you don't need a collection at all.
Using List and Comparator.
List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
list.sort(Comparator.comparing(Map.Entry::getValue));
Using Stream
map.entrySet().stream()
.sorted(Comparator.comparing(Map.Entry::getValue))
//do something here

How to add List of objects in a Map

I have a List and A is defined below.
How do i add in a Map with Key as Long and values as List of Strings.
Class A
{
Long in;
List<String> out;
}
Map<Long,List<String>>

Create a Hashmap object, with key Long and value List. Add items with put(key,value) and retrieve them with get
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<Long,List<String>> myMap=new HashMap<Long,List<String>>();
List<String> myList=new ArrayList<String>();
myList.add("abc");
myList.add("xyz");
myMap.put(new Long(1), myList);
for(int i=0;i<myList.size();i++)
System.out.println(myMap.get(new Long(1)).get(i));
}
}

1.) Create HashMap with Key as Long and value as List<String>.
2.) Use put method of HashMap, as below.
public static void main(String[] args) {
Map<Long, List<String>> myMap = new HashMap<Long, List<String>>();
myMap.put(101L, new ArrayList<String>());
}

How to alphabetize a list of hashmaps [duplicate]

This question already has answers here:
Collections sort(List<T>,Comparator<? super T>) method example [duplicate]
(4 answers)
Closed 9 years ago.
I have an ArrayList defined as so:
ArrayList<HashMap<String, String>> recallList = new ArrayList<HashMap<String, String>>();
Each map only has one element in it company which is the name of a company. My question is how do I alphabetize the ArrayList. I am using this because later down the line (in other views) there will be more elements to the HashMap.

Use the following:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
public class MainClass {
public static void main(String[] args) {
ArrayList<HashMap<String, String>> recallList = new ArrayList<HashMap<String, String>>();
HashMap<String, String> hashMap;
hashMap = new HashMap<String, String>();
hashMap.put("company", "a");
recallList.add(hashMap);
hashMap = new HashMap<String, String>();
hashMap.put("company", "c");
recallList.add(hashMap);
hashMap = new HashMap<String, String>();
hashMap.put("company", "b");
recallList.add(hashMap);
System.out.println(recallList);
Collections.sort(recallList, new Comparator<HashMap<String, String>>() {
#Override
public int compare(HashMap<String, String> hashMap1, HashMap<String, String> hashMap2) {
return hashMap1.get("company").compareTo(hashMap2.get("company"));
}
});
System.out.println(recallList);
}
}
The first and second output are:
[{company=a}, {company=c}, {company=b}]
[{company=a}, {company=b}, {company=c}]

You can use Collections.sort() to sort it in lexicographically order but you have make the object comparable by using Comparator
class CmpHashMap implements Comparator<HashMap<String,String>>
{
public int compare(HashMap<String,String> h1,HashMap<String,String> h2)//assuming second String as company name and key as "key"
{
return h1.get("key").compareTo(h2.get("key"));
}
}
then use collections
Collections.sort(recalllist,new CmpHashMap());