# Sortieren mit generischen Datentypen



## bliko (26. Nov 2009)

Ich habe ein Interface zum Sortieren mit den verschiedenen Sortieralgorithmen geschrieben:

```
public interface Sort<E extends Comparable<E>> {
	public void sort(E[] sammlung);
}
```
Es gibt weiters eine Klasse BubbleSort


```
public class BubbleSort<E extends Comparable<E>> implements Sort<E> {
	// Konstruktor kann hier entfallen
	public void sort(E[] sammlung){
		for (int i=0; i<sammlung.length; i++)
			for (int j=0; j<sammlung.length; i++)
				if (sammlung[j+1].compareTo(sammlung[j])<0) { 
					// vergleichen
					final E temp = sammlung[j+1];
					sammlung[j+1] = sammlung[j];
					sammlung[j] = temp;
				}
	}

}
```

und nun möchte ich das testen, dazu die folgende Klasse SortDemo


```
import film.*;

public class SortDemo {
	
	//static final ArrayList<String> al = new ArrayList(){}; 	
	private static final String testreihe = "EFACHBGD";

	static <E extends Comparable<E>> void sorttest(E[] sammlung, Sort<E> algorithmus){	
		algorithmus.sort(sammlung);
	}
	
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Film[] filme = new Film[]{new Film("007","action", 100), new Film("Sissi", "kitsch", 200)};
		Character[] reihung = new Character[testreihe.length()];
		for (int i = 0; i < reihung.length; i++)
			reihung[i] = testreihe.charAt(i);
		System.out.println("Eingabe: ");
		for (char zeichen : reihung)
			System.out.print(zeichen);
		//Arrays.sort(reihung);
		sorttest(filme, new BubbleSort<Film>());
		sorttest(reihung, new BubbleSort<Character>());
		for(Character c : reihung){
			System.out.print(c + " ");
		}
	}
```

sorttest(reihung, new BubbleSort<Character>());

gibt zwar keine Fehlermeldung aus, doch verfängt sich das Programm in einer Endlosschleife;

sorttest(filme, new BubbleSort<Film>());

hier stimmt der Typ Film nicht, es kommt folgende Fehlermeldung;

Bound mismatch: The type Film is not a valid substitute for the bounded parameter <E extends Comparable<E>> of the type BubbleSort<E>

Mir ist nicht klar, welchen Typ ich da übergeben muss, ich will diese Sortieralgorithmen nämlich mit den verschiedensten Klassen machen können.

Danke im voraus.


----------



## SlaterB (26. Nov 2009)

> for (int j=0; j<sammlung.length; i++)
da steht i++, nicht j++

> Mir ist nicht klar, welchen Typ ich da übergeben muss

wie ist Film definiert?
bei 
class Film implements Comparable<Film> 
müßte es hinhauen, denn das ist ja verlangt von
static <E extends Comparable<E>>


----------



## bliko (26. Nov 2009)

Hier die Definition der Klasse film.java


```
public class Film implements Comparable 
{
	protected String titel, genre;
	protected long laufzeit;
		
	public Film(String titel, String genre, long lfz)
	{
		this.titel = titel;
		this.laufzeit = lfz;
		this.genre = genre;
	}
	
	public String getTitel() {return titel;}
	public long getLaufzeit() {return laufzeit;}
	public String getGenre() {return genre;}
	
	/**
	 * Compares this object with the specified object for order. 
	 * Returns a negative integer, zero, or a positive integer 
	 * as this object is less than, equal to, or greater 
	 * than the specified object.
	 */
	
	public int compareTo(Object mitObj)
	{
		Film mit =  (Film)mitObj;
		if (laufzeit < mit.laufzeit) return -1;
		if (laufzeit > mit.laufzeit) return 1;
		return 0;
	}
	
	public String toString()
	{
		return "[Titel: " + getTitel() + ", Laufzeit= " 
		+  getLaufzeit()+"]";
	}
}
```

Dieser Fehler war tatsächlich gravierend, mit Character läuft es jetzt, doch ich möchte alle Klassen sortieren können. Vorerst schon mal Danke für diesen wichtigen Hinweis.


----------



## SlaterB (26. Nov 2009)

--> 





SlaterB hat gesagt.:


> bei
> class Film implements Comparable<Film>
> müßte es hinhauen, denn das ist ja verlangt von
> static <E extends Comparable<E>>


 <--


----------

