Can one control the identity of objects in Java, and if so, how?

Question

Hi all,

This is a trivial programming question. I am not an expert in Java. Say I use objects of custom classes Company and Employee, in a manner similar to what many RDBMS examples do:

class Employee
{
    Company company;
}

class Company
{
    String name;
}

I need to guarantee that different Company objects have unique names - i.e. no two such objects may have the same name, because from my point of view it makes no sense, and also simply eats memory - if two employees work at IBM, then there is a single Company object with that name, period.

My thoughts right now go along of making Company constructor private - so that the job of allocating Company objects with arbitrary names is delegated to a trusted method - which, suppose, will reject any subsequent attempt to create an object with a name that already exists or return an existing or new object (creating one if necessary).

The problem is, I am not sure how to accomplish this elegantly. One thing that would be nice is not having to do a O(n) lookup every time an Company object with a name is requested - so maybe a hash map or a binary tree is there for my convenience? I would also like to override the way the Company objects are identified - which leads me to this: will I be overriding Object.equals and/or Object.hashCode methods?

Answer 1

You could override equals and hashCode and store them in a HashMap or HashSet.

Answer 2

Take a look at the flyweight pattern.

What I would do is something like:

// incomplete, but you get the idea hopefully
CompanyFactory
{
    private Map<String, Company> companies;

    public getCompany(final String name)
    {
        Company company;

        company = compaines.get(name);

        if(company == null)
        { 
            company = new Company(name);
            companies.put(name, company);
        }

        return (company);
    }
}

Answer 3

One thing that would be nice is not having to do a O(n) lookup every time an Company object with a name is requested - so maybe a hash map or a binary tree is there for my convenience?

That sounds right, yes.

I would also like to override the way the Company objects are identified - which leads me to this: will I be overriding Object.equals and/or Object.hashCode methods?

If you ensure that there are never two instances with the same key value, you actually don't have to do that.

Answer 4

When I want to create a collection of objects that can be looked by by unique names, I store a Map of Strings (names) to Objects. I can then look up the object related to a name.

Strictly speaking, you don't need to touch equals() and hashCode() to do that, as you are not storing your objects as keys. Implementing equals() and hashCode() correctly can be difficult to get right, and keys in a Map implementation like HashMap (which can give you efficient lookups) is sensitive to these methods. Using the existing (and crucially immutable) String class as keys helps you get this lookup functionality right.

---

Update: If you make your constructor private, as you mentioned, you can prevent the creation of new Company instances. Providing some other method of creating Company instances (Factory pattern) allows you ensure that 'new' Company instances are only really new if they are not already stored by name, otherwise the existing instance for a given name is returned (example of Singleton)

Answer 5

If the name of an object can change over time, consider including a generated unique ID for each object. Your mapping would be from name to unique ID, then from unique ID to the actual object.

By the way, if the objects were all known at compile time, you could use an Enum.