Check the keys in the map matching with the List content in Java

Question

I have a List of Strings and a Map. Every key in the map needs to present in the list else I need to throw an exception. As of now I am looping the list and checking the key and throw exception if the map doesn't contains the key. Below is the sample code is what I am doing. IS there any other way in Java8 we can do it in one line or something using streams and filters ?

And also the contents in the list and keys in the map should match. That I am already handling in the separate if condition.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestClass {

    public static void main(String[] args) {

        List<String> ll = new ArrayList<>();
        Map<String, Integer> m = new HashMap<>();
        ll.add("a");
        ll.add("b");
        ll.add("d");

        m.put("a", 1);
        m.put("b", 1);
        m.put("c", 1);

        if(ll.size() != m.size){
       System.out.println("Throw Exception");
         }

        for(String s : ll) {

            if(!m.containsKey(s)) {
                System.out.println("Throw Exception");
            }
        }
    }
}

You are saying different things in your question and in your code. In your question you said you want to check if every key is in the list, but in the code, you are checking if everything in the list is present in the map. — Sweeper, Jan 11 '19 at 07:02
How about this `ll.stream().filter(s -> !m.containsKey(s)).forEach(s -> { throw new RuntimeException("Not found"); }); `? — soorapadman, Jan 11 '19 at 07:06
@Sweeper Sorry , I will modify the question. Technically, the contents in the list and keys in the map should match. — sparker, Jan 11 '19 at 07:10
If they really need to match, then test something like `m.keySet().equals(new HashSet<>(ll))`. Or maybe keep the required keys in a set in the first place. — Stuart Marks, Jan 11 '19 at 07:39
@sparker Seems like what you are expecting your code does is not what it actually is doing. Maybe think about it and rephrase the question to clear out the doubt. — Naman, Jan 11 '19 at 07:52

Naman · Accepted Answer · 2019-01-11T15:59:36.157

Every key in the map needs to present in the list else I need to throw an exception

You could do it using Stream.anyMatch and iterating on the keyset of the map instead as (variable names updated for readability purpose) :

if(map.keySet().stream().anyMatch(key -> !list.contains(key))) {
    throw new CustomException("");
}

Better and as simple as it gets, use List.containsAll :

if(!list.containsAll(map.keySet())) {
    throw new CustomException("");
}

Important: If you can trade for O(n) space to reduce the runtime complexity, you can create a HashSet out of your List and then perform the lookups. It would reduce the runtime complexity from O(n^2) to O(n) and the implementation would look like:

Set<String> allUniqueElementsInList = new HashSet<>(list);
if(!allUniqueElementsInList.containsAll(map.keySet())) {
    throw new CustomException("");
}

Or `if(! map.keySet().stream().allMatch(list::contains))`, but of course, `if(!list.containsAll(map.keySet()))` is the canonical solution. — Holger, Jan 11 '19 at 09:30

Tim Biegeleisen · Answer 2 · 2019-01-11T15:39:47.173

3

We can try adding the list to a set, then comparing that set with the keyset from your hashmap:

List<String> ll = new ArrayList<>();
ll.add("a");
ll.add("b");
ll.add("d");

Map<String, Integer> m = new HashMap<>();
m.put("a", 1);
m.put("b", 1);
m.put("c", 1);

Set<String> set = new HashSet<String>(ll);

if (Objects.equals(set, m.keySet())) {
    System.out.println("sets match");
}
else {
    System.out.println("sets do not match");
}

edited Jan 11 '19 at 15:39

answered Jan 11 '19 at 07:02

Tim Biegeleisen

502,043
27
286
360

1

I think OP is looking for an answer wrt to java-8 *(something using streams and filters)* here. – Nicholas K Jan 11 '19 at 07:30
1

@NicholasK well there is nothing in the code here, that doesn't work with java8., right? But yeah the throwing of exception is definitely missing and also an unwanted creation of Set which doesn't seem to be required for the purpose of OP. – Naman Jan 11 '19 at 07:32
1

Ummm... `if (...m.keySet() == null ...)` ... what is that? The `keySet` can never be `null`, and in any case: the comparison of the `size()` and the `containsAll` call boil down to a simple `if (Objects.equals(m.keySet(), set)) ` ... – Marco13 Jan 11 '19 at 15:02

Nicholas K · Answer 3 · 2019-01-30T17:16:14.277

2

Simply use the following :-

m.keySet().stream().filter(e -> !ll.contains(e))
                   .findAny()
                   .ifPresent(e -> throwException("Key Not found : " + e));

And define the throwException method below :

public static void throwException(String msg) {
    throw new RuntimeException(msg);
}

edited Jan 30 '19 at 17:16

answered Jan 11 '19 at 07:03

Nicholas K

15,148
7
31
57

score 1 · Answer 4 · edited Jan 11 '19 at 07:50

1

You can simply change your existing code to -

if(!m.keySet().containsAll(ll)) {
    System.out.println("Throws Exception");
}

This will solve your problem. :)

edited Jan 11 '19 at 07:50

Naman

27,789
26
218
353

answered Jan 11 '19 at 06:59

prachi

305
1
7

2

This logic has a problem. Should the hashmap's keyset contain _extra_ items, your code would still return true. Also, if `null` on both sides of the comparison means equal, then you would have to cover that case as well. – Tim Biegeleisen Jan 11 '19 at 07:03
@p.bansal - The [same check performed in reverse](https://stackoverflow.com/a/54141925/1746118) was what OP is mostly trying to look forward to. – Naman Jan 11 '19 at 07:34
1

@nullpointer This matches the OP’s code but not the text in the question, which requests the reverse. So +1 from me on this answer. But then the OP said in comments that the map keys must match the list, a yet again different check. (Sigh.) – Stuart Marks Jan 11 '19 at 07:47
@StuartMarks well, if they must match, I’d use `if(m.size() != ll.size() || !m.keySet().containsAll(ll))`, as I suppose, `m.keySet().containsAll(ll)` is potentially faster than `ll.containsAll(m.keySet())`… – Holger Jan 11 '19 at 09:35
@Holger At the time this answer was written, it matched the code in the question. The OP subsequently changed the requirements. – Stuart Marks Jan 11 '19 at 16:15
@StuartMarks I know; you already explained the inconsistency in your comment. So I was saying *if they must match* (the variant that was stated in a comment), I’d suggest that solution. By the time I wrote that comment, I even hadn’t noticed the last edit on the question… – Holger Jan 11 '19 at 16:36

score 1 · Answer 5 · answered Jan 11 '19 at 10:20

Try this:

if ((ll == null && m == null) ||                            // if both are null
   ((ll.size() == m.size() && m.keySet().containsAll(ll)))  // or contain the same elements
) {
    System.out.println("Collections contain the same elements");
} else {
    throw new CustomException("Collections don't match!");
}

ave4496 · Answer 6 · 2019-01-11T11:26:41.640

1

Here is another solution:

    if (ll  .parallelStream()
            .filter(v -> !m.containsKey(v)) // Filter alle values not contained in the map
            .count() == 0) { // If no values are left then every key was present
        // do something
    } else {
        throw new RuntimeException("hello");
    }

Just wanted to show a different approach

edited Jan 11 '19 at 11:26

answered Jan 11 '19 at 11:20

ave4496

2,950
3
21
48

Check the keys in the map matching with the List content in Java

6 Answers6