为下面列出的特定用例处理哈希图中的冲突

Question

I've written a java based web application, simple for now since I'm a beginner in this space. What it does is looks up the phone number of a person, when the user enters the name of the person in the jsp page. I'm using a hashmap for now where I've created two objects the person and the number and basically the map is the association of the person to the number. The reason I have person as an object is later on I plan to add more information to the person object. I also plan to eventually move the association to the database. However, in this specific situation where I have a hash map how do I handle the use case of a "person with the same name" can be two different users because according to my hashmap the key is the person object. Specifically, the user can look up the person by name. I also thought of adding a system generated id to the person object to make it unique but it doesn't solve the use case of two people having the same name as when the user is querying for the phone number he will only enter the person's name.

Answer 1

The simplest solution would be to have your value type be a list of people, so:

Map<String, List<Person>> map = new HashMap...

It sounds like your design could do with a bit of work though. While you're prototyping (pre database), for example, is there any reason you need to use a HashMap? Why not just store a List<Person> , and iterate the list each time you want to search? That would let you easily search on other properties of a person too.

Edit: In response to Phoenix's comment.

The approach is to store a list of all people with the given name in lists within the map.

To add a new person, you need to check if a person already exists with their name, and create an empty list to put them into if there isn't already a person. [Sorry, I don't have a compiler handy, so haven't compiled or tested this, but the idea should be right]

void add(Map<String, List<Person>> map, Person p) {

    if (!map.containsKey(p.name()) {
        map.put(p.name(), new ArrayList<Person>());
    } 
    // The map will always have a (possibly empty) list of people with a given name now
    map.get(p.name()).add(p);
}

Looking people up is easy. To print all the people with a given name:

void printPeople(BufferedWriter out, Map<String, List<Person>> map, String name) {
    for (Person p : map.get(name)) {
        out.println(p.toString());
    }
}

Answer 2

What about this?

Map<String, List<Person>> map = new HashMap<String, List<Person>>();

if(!map.contains(personName)){
    map.put(personName, new ArrayList<Person>());
}

// Construct Person person = new Person(personName, phoneNumber);

map.get(personName).add(person);

You keep a list of person as Martin suggested and put the values as list of person instead of single person.

While iterating...

for(Person person : map.get(personName)){
    // Process person.getPhoneNumber();
}

Answer 3

I'm adding a second answer here. My other answer shows how to implement it with a Map , but I don't think it's worth the effort.

If you're using a HashMap because you're worried about performance, then you'll fix that once you put the database backend in that you've mentioned. As a general rule, don't spend effort optimising code you know you're going to throw away anyway, or don't know for sure even needs optimising.

My solution (pending the real backend), would be to just use a List. You don't need to worry about getting your hashCode algorithm right, and I doubt it's going to come out significantly slower unless you have many thousands of entries.

public class People {
    private List<Person> people = new ArrayList<Person>();

    public void add(Person p) {
        people.add(p);
    }

    public List<Person> findByName(String name) {
        List<Person> result = new ArrayList<Person>();
        for (Person p : people) {
            if (p.getName().equals(name)) {
                result.add(p);
            }
         }
         return result;
     }

It's just so much simpler and clearer than the Map solution.