返回作为HashMap中值的ArrayList的大小

Question

I am working on project that is a spam filter for an email client.

public MailServer()
{
    mailMap = new HashMap<String,ArrayList<MailItem>>();
}

I was instructed to use a HashMap to store the recipients and ArrayLists to hold their mailItems. The next method is to count and return the mailItems for a specific recipient.

public int howManyMailItems(String who)
{
    int count = 0;
    for(MailItem item : mailMap) {
        if(item.getTo().equals(who)) {
            count++;
        }
    }
    return count;
}

---

Edit

I'm working in BlueJ and when I try to compile the class it highlights mailMap in the 4th line and says

"for-each loop not appicable"

 public int howManyMailItems(String who)
{
    int count = 0;
    for(MailItem item : mailMap.keySet()) {
        if(item.getTo().equals(who)) {
            count++;
        }
    }
    return count;
}

When I try a keySet it says incompatible types.

Answer 1

A Map does not implement the Iterable interface. This is why you get the "for-each loop not appicable" error. You have a choice of iterating over the map's

• entrySet() — a Set<Map.Entry<K,V>> (where K is the key type and V is the value type of the map);
• keySet() — a Set<K> ; or
• values() — a Collection<V> .

In general, you would want to do something like this:

public int howManyMailItems(String who)
{
    int count = 0;
    for(Map.Entry<String,ArrayList<MailItem>> entry : mailMap.entrySet()) {
        String key = entry.getKey();
        ArrayList<MailItem> array = entry.getValue();
        // process key and array value
    }
    return count;
}

It's hard to tell exactly what logic you are using to count. If you only need the arrays (and are ignoring the keys to your map), then you can use:

public int howManyMailItems(String who)
{
    int count = 0;
    for(ArrayList<MailItem> array : mailMap.values()) {
        for (MailItem item : array) {
            if (item.getTo().equals(who)) {
                count++;
            }
        }
    }
    return count;
}

PS It's generally considered good practice to declare generic parameter types using interfaces rather than concrete types. For instance, your map could be declared:

Map<String, List<MailItem>>

rather than

Map<String, ArrayList<MailItem>>

(You would have to modify the type used in the iteration loop accordingly.) You can still put instances of ArrayList into the map, but you could also change your mind and put other kinds of List . (For instance, you could then put unmodifiable lists resulting from calls to Collections.unmodifiableList(...) .)

Answer 2

public int howManyMailItems(String who) {
    return mailMap.get(who).size();
}

Answer 3

You're not mentioning any errors, so it's tough to know what's wrong, but usually you iterate through a Map's Key Set, obtained via keySet() , or through its values obtained via values() .

ie,

for(String key : mailMap.keySet()) {
    List<MainItem> itemList = mailMap.get(key);
    count += itemList.size(); // ??? not sure if this is what you want??
    // ... etc..
}

Answer 4

As you have HashMap<String,ArrayList<MailItem>> . The key is type of String and value is ArrayList<MailItem> . The reason of your error is that you fetch the List and try to assign it to MaiItem.

public int howManyMailItems(String who)
{
    int count = 0;

    if(who == null) { //Check the input before operate
      return count;
    }

    for(Iterable<MailItem> iterable : mailMap.values()) { //Interface instead of Class
        for (MailItem item : iterable) {
            if (item == null) { //It is possible that item can be null
               continue;
            }

            if (who.equals(item.getTo())) { //It is possible that To can be null
                count++;
            }
        }
    }
    return count;
}

Why to use Iterable instead of ArrayList in for-each loop ?

The advantage of that solution is that, we do not have to change the code we decide to use another Collection for our storage.

Why Iterable not Collection ?

In this case we perform only read operation, so this is the required minimum to solve the task. The advantage of this is greater code flexibility.