Java store objects in HashMap, keyed by elements field

This isn't supported with any native functionality.

What you would have to do is have a special method somewhere like

public static void updateName(String oldname, String newname, Map<String,MyObject> map) {
    synchronized(map) {
        MyObject obj = map.remove(oldname);
        obj.setName(newname);
        map.put(newname,obj);
    }
}

And document everything properly so developers know to be very careful when changing the name.

Note that this doesn't do the typical error checking (what if it doesn't exist in the old map? what if something is null?) - those sad path cases are left unhandled here. I'm sure they aren't beyond the grasp of a typical programmer. =)

You could do this by adding another object that assigned java.util.UUID to the name and use the UUID as the key in your HashMap. However, you would need another map to manage the UUID to Name mappings. If your class is more involved that just a name this may be the best solution. Otherwise, just remove the old Name from the HashMap and insert a new name. You could implement this in a setName() method and make your name a private property to insure it is not updated directly.

The standard HashMap won't move values between buckets once the value has been inserted. It would be too easy to unexpectedly lose values, if the key change meant that an existing value is now overwritten by the moved value.

You have to do something like corsiKa's solution, though I'd throw an exception before map.remove() if map.get(newname) != null (since otherwise you might unexpectedly lose the existing value at key newname).

Assuming your "Nameable" objects are only ever accessed through the map you can do something like this.

1. Create a class that implements Map.
2. When you return an object from the map, actually return a decorated version (using cglib or something like that), that overrides the setName() method. When setName is called, change the name, but also have the code implementing the decorator update the map with the new key as corsiKa described.

I wonder what is your use case. If you don't change this names often, and/or don't have many objects with name, but you need to find by key often, you could create your own implementation of Map (inheriting from HashMap). There you could store everything as usually, and when get is called, try to do super.get, if it returns null, check all the objects in map, if found, update the map and return the object. So the algorithm looks like this:

1. Try standard implementation get
2. If not found, check all super.values() for desired name
3. If found, put(name, foundObject) and return foundObject

Be careful however, as this might break something if you sometimes assign a name to an object, which was in the past assigned to another object. In such case you could return old object from the map.