Variable parametrisieren

[Bit2_Gosu]

Hi!

Ich habe in einer Klasse die private variable

private Map map;

Jetzt meint mein Compiler aber, und das leuchtet mir auch ein, dass ich Referenzen zum generischen Typ Map paramtrisieren sollte.

Bei Funktionen wüsste ich jetzt, wie das geht - wie geht das aber bei Variablen? Das geht ja leider nicht:

private <K, V> Map <K, V> map;

Jemand eine Idee?

 

[babuschka]

Hallo,

bei Variablen geht das folgendermaßen:

private Map<K,V> map;

Grüße,

Maximilian W

 

[Bit2_Gosu]

Hm, das hatte ich auch schon probiert.

Bei

private Map <K, V> map;

sagt der compiler:

- V cannot be resolved to a type
- K cannot be resolved to a type

Was nun?

 

[maki]

*g*

K steht für die klasse des Keys, V für die Klasse des Values.

zb:

Map <String, Integer> map;

 

[babuschka]

K und V müssen bei Variablen durch die Klasse einer Variable ersetzt werden.

Also z.B.

private Map <String, Object> map;

Grüße,

Maximilian W

[edit]maki war schneller[/edit]

 

[Bit2_Gosu]

Naja wieso, das geht ja auch (wenn die Funktion parametrisiert ist):

public static <K, V> Entry <K, V> getRandomEntry(Map <K, V> map)
{
	Random random = new Random();
	int size = map.size();
	int ranIndex = random.nextInt(size);
	Entry <K, V> e = getEntry(map, ranIndex);
	return e;
}

In meinem Fall möchte ich eine Klasse schreiben, die das Interface "Comparator" implementiert. Die compare Methode, soll die Values zweier Keys einer beliebigen Map vergleichen. Einer Map des Typs <K, V> also:

public class MapValueComparator implements Comparator
{
	private Map <K, V> map;
	
	public <K, V> MapValueComparator(Map <K, V> map)
	{
		this.map = new HashMap <K, V>(map);
	}

	@Override
	public final <K, V extends Comparable <V>> int compare(K a, K b)
	{
		return map.get(a).compareTo(map.get(b));
	}

}

Das ganze scheitert im Moment eigentlich nur daran, dass ich nicht weiß, wie ich die Variable map richtig parametrisiere.

Wenn ich

private Map <String, Integer> map;

nehm, dann kann der Comparator ja nur auf spezielle maps angewendet werden..

Was also tun??

 

[Janus]

public class MapValueComparator<K, V> implements Comparator<K, K>
{ 
   private Map <K, V> map; 
    
   public MapValueComparator(Map <K, V> map) 
   { 
      this.map = new HashMap <K, V>(map); 
   } 

   @Override 
   public int compare(K a, K b) 
   { 
      return map.get(a).compareTo(map.get(b)); 
   } 

}

// ....
Map<String, Integer> map;
// ....
MapValueComparator<String, Integer> sicmp = new MapValueComparator<String, Integer>( map );

 

[Bit2_Gosu]

ah, die ganze Klasse parametrisieren!

Muss man auch erst mal drauf kommen.

Vielen Dank!

So klappts jetzt:

public class MapValueComparator <K, V extends Comparable <V>> implements Comparator <K>
{
	private Map <K, V> map;
	
	public MapValueComparator(Map <K, V> map)
	{
		this.map = new HashMap <K, V>(map);
	}
	
	public final int compare(K k1, K k2)
	{
		return map.get(k1).compareTo(map.get(k2));
	}
}

 

[Bit2_Gosu]

achso noch eine kleine Nachfrage:

wäre es richtiger, statt new map... das zu schreiben:

public class MapValueComparator <K, V extends Comparable <V>> implements Comparator <K>
{
	private Map <K, V> map;
	
	public MapValueComparator(Map <K, V> map)
	{
		this.map = map;
	}
	
	public final int compare(K k1, K k2)
	{
		return map.get(k1).compareTo(map.get(k2));
	}
}

?

 

[Janus]

kommt drauf an, was du erreichen möchtest.

die variante mit der eigenen privaten kopie lässt keine externe manipulation der map zu, wodurch sie sogar eingeschränkt thread safe ist. bei der zweiten variante sind externe manipulationen der map möglich.

in beiden varianten sind externe manipulationen der objekte in der map allerdings trotzdem möglich.

für die semantik eines komparators ist wahrscheinlich die zweite variante "richtiger".

 

[Bit2_Gosu]

gut vielen Dank!