I have the following Map:
HashMap<String, String> map1= new HashMap<String, String>();
map1.put("1", "One");
map1.put("2", "Two");
map1.put("3", "Three");
I have a list numbers which contains ["1","2","3"]
I have to perform the following operations:
List<String> spelling= new ArrayList<>();
for (String num: numbers) {
if (map1.containsKey(num)){
spelling.add(map1.get(num))
}
}
How can I write the above code using lambda Expressions?
Use a Stream:
List<String> spelling = numbers.stream()
.map(map1::get)
.filter(Objects::nonNull)
.collect(Collectors.toList());
System.out.println (spelling);
Note that instead of checking if a key is in the map with containsKey, I just used get, and then filtered out the nulls.
Output:
[One, Two, Three]
.filter(Objects::nonNull) ? I mean map will return only those objects which matched the passed key..
map1.get(k) will return null..filter(Objects::nonNull)
map1 would possibly contain null values, this solution might give an unexpected result (depending on whether you want to retain those null values in the output)map1 contains null values and you wish to keep them in the output, you'll have to use .filter(k->map1.containsKey(k)).A variant of Erans solution:
containsKey instead of checking null values => if map1 would contain null values, checking null values would give a wrong result.Code fragment:
List<String> spelling = numbers.stream()
.filter(map1::containsKey)
.map(map1::get)
.collect(Collectors.toList());
System.out.println (spelling);
Map.get twice. There is no reason to do this; Eran's answer is better.null values, using containsKey is simply the only way, and Erans answer will yield wrong results. Even if you don't want to retain null values, one could argue that the version with containsKey expresses more clearly the intention of the code.containsKey is required. But I'm not sure that the intent argument is valid - I would argume that the intent is clear either way but that using containsKey has double the overhead of the null check.another option would be to use the forEach construct:
numbers.forEach(n -> {
if(map1.containsKey(n))
spelling.add(map1.get(n));
});
foreach loop, besides complexity. I dislike these uses of forEach.
foreach loop . However, it's just that OP wanted to use "lambda" and hence the suggestion.Try like this
List<String> spelling = map1.keySet().stream()
.filter(numbers::contains)
.map(map1::get)
.collect(Collectors.toList());
O(n*m) solution (n is map1.size(), m is numbers.size()) rather than an O(m) solution.
numbers list, as HashMap has no guaranteed iteration order.