Question

To give a simple example, consider a Place class:

public class Place {

    //fields
    private String name;

    private String state;

    private int population;

    private int squareMileage;

    private int elevation;

    //constructors
    public Place() {    
    }

    public Place(String name, String state) {
        this.name = name;
        this.state = state;
    }

    public Place(String name, String state, int population, int squareMileage, 
                    int elevation) {
        this.name = name;
        this.state = state;
        this.population = population;
        this.squareMileage = squareMileage;
        this.elevation = elevation;
    }

    //getters and setters
    public String getName() {
        return this.name;
    }

    public String getState() {
        return this.state;
    }
    //... (other getters and setters omitted)

    //do stuff
}

And a Places class (a HashMap of Place objects):

import java.util.*;

public class Places {
    private Map searchablePlaces;

    public Places() {
        searchablePlaces = new HashMap();
    }

    public void add(Place value) {
        Place key = new Place(value.getName(), value.getState());
        searchablePlaces.put(key, value);
    }

    public Place find(Place key) {
        return searchablePlaces.get(key);
    }

    //override hashCode, equals

    //do stuff
}

Essentially, my question is:

1. Would there be any efficiency gained in searching the HashMap for key, as opposed to searching for value directly in, let’s say, a sorted ArrayList?
2. What if key was of type String equal to name + state (or of type String[2])?

Answer 1

It’s confusing, IMHO. I would define a PlaceKey class, holding just a name and a state and defining hashCode and equals. A place would hold a PlaceKey, and other attributes. And I would use a Map<PlaceKey, Place>.

Note that, in your example, it’s the Place class that needs equals and hashCode, not the Places class.

Now, to answer your 2 questions :

1. a hash map is O(1), and a list is O(n). A map will thus usually be faster (except perhaps for very small n values)
2. concatenating is almost always a bad idea. You could have name1 = aa, state1 = a, name2 = a and state2 = aa, which would result in a collision. An array doesn’t override equals and hashCode in terms of their content, and is not an appropriate map key class.