Map<T,T> possible in non-generic class?

[Tim99]

Hi,

in my (not generic) class, I want to map generic objects onto other objects of the same type: Map<T,T>.

Examples:
String --> String should be possible
Double --> Double as well
String --> Double should not be possible.

I tried this:

public class MyClass {

  private Map<T, T> myMap = new HashMap<T, T>>();

  public T get(T key) {
    return myMap.get(key);
  }

}

Any help would be greatly appreciated!

[KevinWorkman]

What you're trying to do IS a class containing generics. Why don't you just declare T in the class header?

[Tim99]

Because one instance of this class should be able to store *both* Double-->Double or String-->String. All combinations of key/value should be possible as long as they are both of the same type.

With e.g. MyClass<Double>, I wouldn't be able to store String-->String.

[DarrylBurke]

So you want a Map where the keys and values have to be of the same Type? That's a contract better represented in an interface than in the generic parameters of a class field.

interface MapT<T> extends Map<T, T> {
}

A concrete implementation could be as simple as

class HashMapT<T> extends HashMap<T, T> implements MapT<T> {
}

or could wrap a HashMap<T, T> and forward all method calls to the wrapped map

@SuppressWarnings("element-type-mismatch")
class HashMapT<T> implements MapT<T> {

  private Map<T, T> map = new HashMap<T, T>();

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

  @Override
  public boolean isEmpty() {
    return map.isEmpty();
  }

  @Override
  public boolean containsKey(Object key) {
    return map.containsKey(key);
  }

  @Override
  public boolean containsValue(Object value) {
    return map.containsValue(value);
  }

  @Override
  public T get(Object key) {
    return map.get(key);
  }

  @Override
  public T put(T key, T value) {
    return map.put(key, value);
  }

  @Override
  public T remove(Object key) {
    return map.remove(key);
  }

  @Override
  public void putAll(Map<? extends T, ? extends T> m) {
    map.putAll(m);
  }

  @Override
  public void clear() {
    map.clear();
  }

  @Override
  public Set<T> keySet() {
    return map.keySet();
  }

  @Override
  public Collection<T> values() {
    return map.values();
  }

  @Override
  public Set<Map.Entry<T, T>> entrySet() {
    return map.entrySet();
  }

  @Override
  public String toString() {
    return map.toString();
  }

  @Override
  public boolean equals(Object obj) {
    if (obj == this) {
      return true;
    }
    if (!(obj instanceof HashMapT)) {
      return false;
    }
    return map.equals(((HashMapT) obj).map);
  }

  @Override
  public int hashCode() {
    return map.hashCode();
  }
}

db

[Tolls]

That still doesn't fulfill the OPs requirements, which appear to be a desire to store, in the same Map, Doubles, Strings, Integers etc, but the key and value need to be the same.

I doubt that's doable using generics, and will probably require type checking code.

[DarrylBurke]

That still doesn't fulfill the OPs requirements, which appear to be a desire to store, in the same Map, Doubles, Strings, Integers etc, but the key and value need to be the same.

I doubt that's doable using generics, and will probably require type checking code.

Oh. I misunderstood the requirement to be to create separate Maps where in each Map the key and value would be of the same generic type.

I agree that Generics can't specify the requirement as I now understand it. But this requirement also looks like being a badly flawed design.

db

[Tolls]

Oh. I misunderstood the requirement to be to create separate Maps where in each Map the key and value would be of the same generic type.

I agree that Generics can't specify the requirement as I now understand it. But this requirement also looks like being a badly flawed design.

db

Got to admit that I can't guarantee my interpretation is correct...:)

[KevinWorkman]

This seems almost possible, but I agree with Darryl's opinion that this seems like a bad design.

The closest I can come up with is something like this:

import java.util.HashMap;
import java.util.Map;

public class MapTest {

	Map<Object, Object> map = new HashMap<Object, Object>();
	
	public <T> void put(Class<T> c, T key, T value){
		map.put(key, value);
	}
	
	public <T> T get(Class<T> c, T key){
		return (T) map.get(key);
	}
	
	
	public static void main(String... args){
		
		MapTest mapTest = new MapTest();
		
		
		mapTest.put(String.class, "cats", "test");
		mapTest.put(Integer.class, 10, 1);
		
		mapTest.put(String.class, "cats", 10); //compiler error!
		
		System.out.println(mapTest.get(String.class, "cats"));
		System.out.println(mapTest.get(Integer.class, 10));
		
		System.out.println(mapTest.get(Integer.class, "cats")); //compiler error!
	}
}

This is quite a bit of a kludge, as the compiler warnings indicate, but at least it does accomplish the goal of converting possible runtime errors into compile-time errors instead.

[Tolls]

I would say "nice job", but I suspect you feel unclean coming up with that...:)

[KevinWorkman]

I would say "nice job", but I suspect you feel unclean coming up with that...:)

Ha! Ask for a dirty design, get a dirty solution...