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>());
}
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'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.
I want to create list by doing this
List<String> myList = new ArrayList<String>();
but it's not recognized, i don't know why:
Eclipse suggest me to modify the syntax :
First eclipse consider that the type List is not generic and it removes the first String brackets
List myList = new ArrayList<String>();
and then change the type of my List and finally i have :
ArrayList<String> myList = new ArrayList<String>();
I really don't understand why it doesn't work.
How to make a new List in Java
I read this post and try again with an other type it's the same problem.
EDIT:my code look like this
import java.util.ArrayList;
import java.awt.List;
public class Test {
public static void main(String[] args){
List<String> myList = new ArrayList<String>();
}
}
The problem was solved by changing
import java.awt.List;
to
import java.util.List;
Does your code look like this?
import java.util.ArrayList;
import java.util.List;
public class Example {
public static void main(String[] args) throws Exception {
List<String> myList = new ArrayList<String>();
}
}
How can I convert a List of Objects to corresponding List of Strings without scanning all elements by for loop?
You could try this:
List<String> variable = (List<String>)(List<?>) yourList;
In the comments you specified that you wanted to call the toString() method. This is possible with guava (https://code.google.com/p/guava-libraries/):
import com.google.common.base.Function;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.List;
public class Application {
public static void main(String[] args) {
Function<Object, String> objectToString = new Function<Object, String>() {
public String apply(Object object) {
return object.toString();
}
};
List<Object> yourList = new ArrayList<Object>();
yourList.add("foo");
List<String> strings = Lists.transform(yourList, objectToString);
}
}
So, after request of compiling code, here it is. And the problem is that after adding second Hash element Called "B", the output messes up.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class test {
public static void main(String[] args) {
Map<String, List<List<Double>>> alphabet = new HashMap<String,List<List<Double>>>();
List<List<Double>> something = new ArrayList<List<Double>>();
List<Double> stuffList = new ArrayList<Double>();
stuffList.add(3.1);
stuffList.add(3.2);
stuffList.add(3.3);
something.add(stuffList);
alphabet.put("A", something);
System.out.println(something);
System.out.println(alphabet);
stuffList.clear();
something.clear();
stuffList.add(3.4);
something.add(stuffList);
alphabet.put("B", something);
System.out.println(something);
System.out.println(alphabet);
}
}
The output is:
[[3.1, 3.2, 3.3]]
{A=[[3.1, 3.2, 3.3]]}
[[3.4]]
{A=[[3.4]], B=[[3.4]]}
Which in my opinion and needs, should be:
[[3.1, 3.2, 3.3]]
{A=[[3.1, 3.2, 3.3]]}
[[3.4]]
{A=[[3.1, 3.2, 3.3]], B=[[3.4]]}
You are still referencing old instances of the lists. This should work as expected:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class test {
public static void main(String[] args) {
Map<String, List<List<Double>>> alphabet = new HashMap<String,List<List<Double>>>();
List<List<Double>> something = new ArrayList<List<Double>>();
List<Double> stuffList = new ArrayList<Double>();
stuffList.add(3.1);
stuffList.add(3.2);
stuffList.add(3.3);
something.add(stuffList);
alphabet.put("A", something);
System.out.println(something);
System.out.println(alphabet);
// Create new instances:
something = new ArrayList<List<Double>>();
stuffList = new ArrayList<Double>();
stuffList.add(3.4);
something.add(stuffList);
alphabet.put("B", something);
System.out.println(something);
System.out.println(alphabet);
}
}
In Java objects are always taken by reference.
Which means that
stuffList.clear();
something.clear();
stuffList.add(3.4);
operates on the same lists you put in the map by the key "A".
So in the end the map contains the same list twice.