有关使用HashMap的方式的设计实现

Question

When showing accounts in the GUI, I need to show primary accounts ( for secondary accounts ) There can be multiple secondary accounts for each primary account.

I am trying to save the primary to secondary accounts information in the HashMap. Because, that needs to be retrieved later.

While saving, I also need to save secondary account instruction. So, I need to save two objects with key as Primary account.

1) Secondary Account
2) Secondary Instruction.

I have equals and hashcode overridden for account and instruction objects.

I am trying to use Primary account hashcode as key and value as a List of Object[2]

-- Initialization

private static final Map<Integer, ArrayList<Object[]>> primaryToSecondaryAcct = new ConcurrentHashMap<Integer, ArrayList<Object[]>>();

-- Putting values

final Object[] acctInstr = new Object[2];
acctInstr[0] = acct;
acctInstr[1] = instr;
if(primaryToSecondaryAcct.get(getExistingAccount().hashCode()) != null) {
    primaryToSecondaryAcct.get(getExistingAccount().hashCode()).add(acctInstr);
} else {
    final ArrayList<Object[]> acctInstrList = new ArrayList<Object[]>();
    acctInstrList.add(acctInstr);
    primaryToSecondaryAcct.put(getExistingAccount().hashCode(), acctInstrList);
}

I am wondering if this is correct and if there a better way of doing it. Could you suggest?

Answer 1

Instead of:

Map<Integer, ArrayList<Object[]>>

why not have

Map<Account, SecondaryInfo>

At the moment you're storing a collection against the key, and you have to manage that, iterate through it etc. when you pull it from the Map . I think it's much better to create a suitable abstraction and delegate to it. That abstraction will look after validation, iteration etc. in one location, rather than you having to worry about it each time you access the Map .

Remember - OO is about telling objects to do things for you , not asking them for info and doing it yourself.

I would replace your Integer representation of an account by a specific Account object. otherwise you're going to have to manage lots of integers representing different types, and it's very easy to mix these up. Typing them (albeit using a trivial class) means you can refactor trivially using automated tools and easily determine types without resorting to naming conventions.

Answer 2

我建议使用Account作为密钥，因为两个不同对象的哈希码可以相同。

Answer 3

The first thing you want is a MultiMap , which you can find in the Guava library from Google. This is similar to a Map<K, Collection<V>> , and maps a key to multiple values for you so you don't have to reinvent that.

Next, replace Object[] with your own custom class:

public class SecondaryInformation {
    private SecondaryAccount secondaryAccount;
    private SecondaryInstruction secondaryInstruction;

    // Constructors, getters, setters, etc.
}

So you'll have a MultiMap<Integer, SecondaryInformation> . Here's some wiki info on the MultiMap .

Answer 4

If for both Primary and Secondary accounts you have classes as follows:

public class PrimaryAccount 
{
    int id;
    private List<SecondaryAccount> secondaryAccounts;   
}

public class SecondaryAccount
{
    int id;
    private List<String> instructions;
    PrimaryAccount primaryAccount;
}

Then, perhaps you will not even need HashMap . However, you may still want to maintain a Hashmap for quick look up of Accounts: HashMap<Integer,PrimaryAccoount> , where you will store account id and primary account.

This makes the implementation cleaner. How ever you do need write classes for Primary and Secondary accounts.