Re: How to use hash map to store values of function.

Sanny wrote:


GArlington wrote:


In addition to GArlington's good advice, you might want an entity class to
represent your "primary key" information, in this case the tuple (carname,
Modelnumber). We'll change those names, now, to match Java coding
conventions, camel case with lower-case first letter for methods and
variables, upper-case first letter for classes, etc.:

  public class Key
  {
   private final String carName;
   private final Integer model;

   private final transient int hash;

   public Key( String car, Integer mod )
   {
     if ( car == null || mod == null )
     {
       throw new IllegalArgumentException(
             new NullPointerException(
             "null key" ));
     }
     this.carName = car;
     this.model = mod;
     assert this.carName != null && this.model != null;

     hash = carName.hashCode() * 31 + model.hashCode();
   }
   public final String getCarName() { return carName; }
   public final Integer getModel() { return model; }
   @Override public boolean equals( Object o )
   {
     if ( ! getClass().isInstance( o ))
     { return false; }
     Key ok = (Key) o;
     return (carName.equals( ok.carName )
            && model.equals( ok.model ));
   }
   @Override public int hashCode()
   {
     return hash;
   }
  }

Make your Map a Map < Key, CarValue >.

Key is amenable to serialization, with the caveat that you need to make a
defensive copy on the read from the stream. This will regenerate the
transient hash cache.

Key is amenable to genericization if you make it Key <T>, and make model type
T. Change the variable 'carName' to 'name'. If T is mutable you will need to
make an immutable copy of the constructor argument. Defensive copy on
deserialization becomes even more important.

JPA frameworks and the like, such as Hibernate and OpenJPA, are a lot like this.

A full-blown entity class will sport dependent attributes keyed by the primary
key component. So the whole entity class will comprise a Key component /and/
the Value class component:

  public class Entity <K, V>
  {
   private final Key<K> key;
   private V value;
   public Entity( K k, V v )
   { // standard check for null key
     key = k;
     value = v; // null allowed
   }
  // etc.
  }

Now your map is Map < K, Entity < K, V >>.

In a database the key is represented by the key columns, and the value by the
dependent columns in a table. Either type K or V may represent tuples of
other typed attributes.

--
Lew