Java中是否可以有另外两个地图作为后盾？

Question

I have two maps in my application, let it be 'users by id' and 'managers by id'. I use them to get user by its id:

Map<Id, Person> usersById = new HashMap<Id, Person>();
Map<Id, Person> managersById = new HashMap<Id, Person>();
Person me = usersById.get(myId);

Both the entities are persons, so sometime I need to find an arbitrary person by its id. Yes, I can search in one map and then in another one:

Person findArbitraryPerson(Id id) {
    Person candidate = usersById.get(myId);
    if (candidate == null) {
      candidate = managersById.get(myId);
    }
    return candidate;
}

But, may be, there is a better approach? Yes, I can create a common map of persons. But I would have to add a new Person instance to that map each time it arrives, and remove it etc. Is it possible to create a kind of a 'backed by two maps' map, to renew it contents automatically? Just as I can create a subMap backed by original map in Collections framework.

Or, may be, there is a better solution?

Answer 1

An extension (and/or conclusion) to my comment and @BrianRoach's comment :

public abstract class Person {
   // general members and methods shared by managers and users
}

public class User extends Person {
    // User specific members and methods
}

public class Manager extends Person {
   // Manager specific members and methods
}

Map<Id,Person> map = new HashMap<Id, Person>();
map.put(new Id(), new Manager());
map.put(new Id(), new User());

OR (if you were so inclined), just have a boolean member on the Person object: isManager with appropriate getter/setter.

Answer 2

Here is a readonly Map (untested !), which is backed up by any number of other Maps:

 private class ReadonlyProxyMap<K, V> implements Map<K, V> {

        private final List<Map<K, V>> maps = new ArrayList<>();

        public void addMap(Map<K, V> map) {
            maps.add(map);
        }

        @Override
        public int size() {
            return entrySet().size();
        }

        @Override
        public boolean isEmpty() {
            for (Map<K, V> map : maps) {
                if (!map.isEmpty()) {
                    return false;
                }
            }
            return true;
        }

        @Override
        public boolean containsKey(Object key) {
            for (Map<K, V> map : maps) {
                if (map.containsKey(key)) {
                    return true;
                }
            }
            return false;
        }

        @Override
        public boolean containsValue(Object value) {
            for (Map<K, V> map : maps) {
                if (map.containsValue(value)) {
                    return true;
                }
            }
            return false;
        }

        @Override
        public V get(Object key) {
            for (Map<K, V> map : maps) {
                if (map.containsKey(key)) {
                    return map.get(key);
                }
            }
            return null;
        }

        @Override
        public V put(K key, V value) {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }

        @Override
        public V remove(Object key) {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }

        @Override
        public void putAll(Map<? extends K, ? extends V> m) {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }

        @Override
        public void clear() {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }

        @Override
        public Set<K> keySet() {
            Set<K> keySet = new HashSet<>();
            for (Map<K, V> map : maps) {
                keySet.addAll(map.keySet());
            }
            return keySet;
        }

        @Override
        public Collection<V> values() {
            List<V> values = new ArrayList<>();
            for (Map.Entry<K, V> entry : entrySet()) {
                values.add(entry.getValue());
            }
            return values;
        }

        @Override
        public Set<Map.Entry<K, V>> entrySet() {
            Set<K> keySet = new HashSet<>();
            Set<Map.Entry<K, V>> entrySet = new HashSet<>();
            for (Map<K, V> map : maps) {
                for (Map.Entry<K, V> entry : map.entrySet()) {
                    if (!keySet.contains(entry.getKey())) {
                        entrySet.add(entry);
                        keySet.add(entry.getKey());
                    }
                }
            }
            return entrySet;
        }

    }

Then you can use:

Map<Id, Person> usersById = new HashMap<>();
Map<Id, Person> managersById = new HashMap<>();
ReadonlyProxyMap<Id, Person> allPersons = new ReadonlyProxyMap<>();

...

allPersons.addMap(usersById);
allPersons.addMap(managersById);

...

Person findArbitraryPerson(Id id) {
    return allPersons.get(myId);
}

Answer 3

Surely managers are also people? The better way to do this is to have a map of Person s and have Manager extend Person .

To get a person query the map and return the found Person . To get a manager query the map and check if the returned object is an instanceof Manager and return null if it is not.

I would wrap the whole HashMap into a class of your own and that class should implement getPerson() , getManager() , getUser() with appropriate calls/checks. This also decouples the API from the implementation so in future you can always change it and not have to change any other code.