I am currently using HashMap<String, Integer> which is filled with keys of type String which are all, let's say, 5 chars long. How can I search for an specific key of 4 chars or less, which is part and at the beginning of some other keys and get all hits as a collection of <Key, Value>?

7

8 Answers

Iterate is your only option unless you create a custom data structure:

for (Entry<String, Integer> e : map.entrySet()) { if (e.getKey().startsWith("xxxx")) { //add to my result list } }

If you need something more time efficient then you'd need an implementation of map where you are tracking these partial keys.

It seems like a use case for TreeMap rather than HashMap. The difference is that TreeMap preserves order. So you can find your partial match much quicker. You don't have to go through the whole map.

Check this question Partial search in HashMap

You cannot do this via HashMap, you should write your own implementation for Map for implementing string length based searching in a map.

4
Map<String, Integer> result = new HashMap<String, Integer>; for(String key : yourMap.keySet()) { if(key.length() == 4){ result.put(key, yourMap.get(key); } }

After executing this code you have all key/value pairs with 4 letter keys in result.

0
Set<Entry<String, Integer>> s1 = map.entrySet(); for (Entry<String, Integer> entry : s1) { if(entry.getKey().length == 4) //add it to a map; }

First get the entry set to your hashmap. Iterate through the set and check the length of each key and add it to a map or use it as u want it.

With HashMap<String, Integer> you can only go through keySet() and do contains() for String keys and your pattern.

As has been noted, there isn't a terribly efficient* way to do it with the datastructure you have specified. However, if you add an additional Map<Integer, List<String>> to keep track of the mapping from string length to the list of all keys with that length, then you will be able to do this very efficiently.

*Using just the Map<String, Integer>, you would need to iterate through the entire capacity of the larger map, whereas adding this supplemental datastructure would impose an O(1) lookup (assuming you used a HashMap) followed by iteration through just the result set, which is the fastest possible outcome.

You can try this approach:

public Map<String,Integer> filterMap(Map<String, Integer> inputMap){ Map<String, Integer> resultHashMap = new HashMap<String, Integer>(); for (String key : inputMap.keySet()) { if(key.length()==5){ resultHashMap.put(key,inputMap.get(key)); } } return resultHashMap; }