Mittels Generics eine Methode verallgemeinern

[Krabat]

Hallo,
ich habe eine HashMap, um schnell auf meine "JobWrapper" Daten zugreifen zu können. Mit der unteren Methode sollen die toString() Representanten der JobWrapper Elemente sortiert werden, allerdings nicht nach der Reihenfolge der toString Ausgabe, sondern nach den Comparable-Kriterium von JobWrapper. Das funktioniert soweit, nur ist mir eine Warning nicht ganz klar und die Verallgemeinerung der Methode bereiten mir noch Schwierigkeiten.

	private String[] sortCache(Map<String, JobWrapper> cache, boolean reverseOrder) {
		List<JobWrapper> list = new Vector<JobWrapper>(cache.values());
		if (reverseOrder) {
			Collections.sort(list, Collections.reverseOrder());
		} else {
			Collections.sort(list);  //WARNING hier
		}

		String[] str = new String[list.size()];
		for (int i=0; i<list.size(); i++) {
			str[i] = list.get(i).toString();
		}
		return str;
	}

1. Wieso kommt die Warnung "Type safety: Unchecked invocation sort(List<JobWrapper>) of the generic method sort(List<T>) of type Collections"? Ich benutze doch bereits die Generics-Version, oder?

	private String[] sortCache(Map<?, ?> cache, boolean reverseOrder) {
		List<?> list = new Vector<?>(cache.values());   //ERROR hier
		if (reverseOrder) {
			Collections.sort(list, Collections.reverseOrder());
		} else {
			Collections.sort(list);
		}

		String[] str = new String[list.size()];
		for (int i=0; i<list.size(); i++) {
			str[i] = list.get(i).toString();
		}
		return str;
	}

2. Nun möchte ich eine allgemeinere Methode für weitere Maps haben. Dies wollte ich über die Generics lösen, das scheint aber so nicht zu funktionieren. Oben mein fehlerhafter Ansatz(Fehlermeldung: "Cannot instantiate the type Vector<?>", da vermutlich der Typ von Vector bereits bekannt sein muß!?):

 

[clemson]

bei deiner ersten variante muss die klasse / das interface JobWrapper das interface Comparable implementieren.

public static String[] sortCache(Map<String, JobWrapper> cache, boolean reverseOrder)
{
	List<JobWrapper> list = new Vector<JobWrapper>(cache.values());
	if (reverseOrder)
	{
		Collections.sort(list, Collections.reverseOrder());
	}
	else
	{
		Collections.sort(list);
	}

	String[] str = new String[list.size()];
	for (int i = 0; i < list.size(); i++)
	{
		str[i] = list.get(i).toString();
	}
	return str;
}

public interface JobWrapper extends Comparable<JobWrapper>
{

}

bzw.

public class JobWrapper implements Comparable<JobWrapper>
{

	public int compareTo(JobWrapper jobWrapper)
	{
		// comparison implementation
		return 0;
	}

}

bei deiner zweiten variante musst du der list mitteilen, dass dein zu sortierendes objekt Comparable implementieren muss, da ja ansonsten nicht sortiert werden kann...

public static <T extends Comparable<? super T>> String[] sortCache(Map<String, T> cache, boolean reverseOrder)
{
	List<T> list = new Vector<T>(cache.values());
	if (reverseOrder)
	{
		Collections.sort(list, Collections.reverseOrder());
	}
	else
	{
		Collections.sort(list);
	}

	String[] str = new String[list.size()];
	for (int i = 0; i < list.size(); i++)
	{
		str[i] = list.get(i).toString();
	}
	return str;
}

 

[Krabat]

Cool. Funktioniert optimal!

Die Warnung kam, obwohl ich Comparable implementiert hatte, ...

public class JobWrapper implements Comparable, Representable {...}

ich kannte die Generic-Variante von Comparable noch nicht. Dies hat die Warnings beseitigt:

public class JobWrapper implements Comparable<JobWrapper>, Representable {...}

Die Verallgemeinerung funzt nun, wie ich es mir angedacht hatte. Dank' Dir!!