Comparator für Generiks

[syscon]

Hi,
bin grad dabei den mergesort zu implementieren. Dafür will ich einen Comperator schreiben der auf Generiks funktioniert heißt jeden ihm implementierten Datentyp sortiert!

Nun weiß ich nicht wie ich ihm sage wenn T der und der Typ ist nehme diese Methode

Mir ist nun nicht ganz klar wie ich das implementiere.

import java.util.*;


public class Compare implements Comparator <Tr> {

public int compare(Integer o1, Integer o2) {
		
		if(o1>o2){
			
		return 1;
			
		} if (o1<o2){
		return -1;
		}
		
		else return 0;
	}
	
}

 

[Gast2]

Mir ist nicht ganz klar was du meinst. Vor allem der Satz "wenn T der und der Typ ist nehme diese Methode" klingt ein wenig kryptisch.

Folgendes kompiliert schonmal...

public class Compare<T> implements Comparator<T> {
	public int compare(T o1, T o2) {
		// ...
	}
}

 

[syscon]

Ja genau ... aber wie will ich dann T vergleichen wenn ich jetzt noch nicht weiß was T ist.

Gibt es eine möglichkeit der Klasse zu sagen :

Wenn T = Integer dann Sortiere nach

o1>o2 oder o2>o1 oder beides ist gleich:

wenn T aber z.B. die Abstrakte Klasse Haus ist dann sortiere so und so

geht das hier mal mein Anfang ist aber bestimmt Falsch!:

import java.util.*;

// Dies ist nur ein Beispiel Comparator fom Typ Integer 

public class Compare<T> implements Comparator <T> {

	

	
	
	
	
	
	public int compare(Element<T> o1,Element<T> o2) {
		
	if ((""+(o1.inhalt).getClass()).equals("java.lang.Integer")){
		
	if(o1.inhalt>o2.inhalt){
		
	}
	
	
	
	
	}
		
		
		
	}
	
	
	
	
	
	
}

 

[Gast2]

Musst du die Ts denn unbedingt selbst vergleichen? Reichts nicht aus, dass du weißt dass die sortiert werden können? Da du ja ein mergesort programmieren willst sollte das doch eigentlich ausreichen. Dann kannst du deine Klasse z.b. so aufbauen:

public class Compare<T extends Comparable<T>> {
	public void doIt(T t) {
		// t.compareTo(otherT);
	}
}

 

[Spacerat]

Mir ist nicht ganz klar was du meinst. Vor allem der Satz "wenn T der und der Typ ist nehme diese Methode" klingt ein wenig kryptisch.

Folgendes kompiliert schonmal...

public class Compare<T> implements Comparator<T> {
	public int compare(T o1, T o2) {
		// ...
	}
}

Wow... ist das nicht das selbe (oder gleiche... oder wie auch immer) wie:

Comparator<MyClass> compare = new Comparator<MyClass>() {
    public int compare(MyClass o1, MyClass o2) {
        // ...
    }
};

? Naja... egal. Wichtig ist nur, dass der Comparator nur dazu da ist Objekte gleichen oder höheren Klassentyps miteinander zu vergleichen, die eigentlich nicht Comparable sind. Das Problem dabei ist, das die "compare()"-Methode nun Klassenabhängig ist. Da kannst du Comparator implementieren, wie du willst, die "compare()"-Methode wird immer anders aussehen. Standardmässige vergleiche beliebiger Objekte funktionieren nur mit "hashCode()" oder mit "toString()" oder hat da noch jemand andere Vorschläge?

public class ObjectComparator implements Comparator<Object> {
	public int compare(Object o1, Object o2) {
		return o1.toString().compareTo(o2.toString() /* vodafone.toFloat() :lol: */);
	}
}

 

[Marco13]

Das... ähm. geht so nicht. Man kann T's nicht vegleichen, darum geht es ja: T kann irgendwas sein. Da, wo der Comparator erstellt wird, muss man schon dazusagen, was es er vergleicht. Beschreib' ggf. mal genauer, wo du den Comparator brauchst. Er wird ggf. "von außen" dort hin durchgereicht werden müssen (d.h. von irgendwo, wo man weiß, was das T an dieser Stelle sein wird)

 

[syscon]

Hi,

also ich möchte auf einer Liste den Merge Sort einbauen :

Mergesort ? Wikipedia

Also im Grunde was Collection.sort macht !

Collections (Java Platform SE 6)

Jetzt hab ich meine Klasse DoppelListe geschrieben und möchte noch den Sort Algo implementieren:

Haben jetzt schon verstanden das man Java nun sagen muss das <Sortable> Comparable implementiert haben muss.

Meine Frage ? wo muss ich das implementieren laut "Java von Kopf bis Fuß" S.547 steht man soll es so implementieren:

public static <T extends Comperable<? super T>> void sort(List<T> list){


}

aber wenn ich das so implementiere sagt er mir :

Comparable Can not be resolved to a type,
bound mismatch

So schreibe ich das oben in den Klassenkopf dann gibt er mir zwar keine Fehlermeldung aber er sagt dann:

"antworte can not be resolved to a type"!!! was auch immer das heißt: in Zeile 68 bei return tmp;

public class DoppelListe <Sortable extends Comparable <? super Sortable>>{

//Hier stehen alle Methoden die vollständige Doppelt verlinkte Liste implementieren muss!




public DoppelListe<Sortable> mergesort(DoppelListe<Sortable> liste){
	    if (size() <= 1){ return liste;}
	    else{
	        DoppelListe<Sortable> linkeListe=new DoppelListe();
	        DoppelListe<Sortable> rechteListe=new DoppelListe();
	        int i=0;
	        while( i < size()/2){
	        
	       linkeListe.add(get(i));
	        i++;
	        }
	        while( i <= size()){
		        
	 	       rechteListe.add(get(i));
	 	        i++;
	 	        }
	        
	        linkeListe = mergesort(linkeListe);
	        rechteListe = mergesort(rechteListe);
	        return merge(linkeListe, rechteListe);
	    
	    }
	    }
	   
	    public DoppelListe<Sortable> merge(DoppelListe<Sortable> linkeListe,DoppelListe<Sortable> rechteListe){
	    	
	    	DoppelListe<Sortable> tmp=new DoppelListe();
	    	   while (linkeListe != null && rechteListe != null){
	    		   
	    		   if(linkeListe.get(0).compareTo(rechteListe.get(0))==-1 || linkeListe.get(0).compareTo(rechteListe.get(0))==0) 
	    		   
	    		   {
	    			   
	    			tmp.add(linkeListe.get(0));
	    		   }
	    		   
	    		   else{
	    			   
	    			   tmp.add(rechteListe.get(0)); 
	    			   
	    		   }
	    		   
	    		  
	    		   
	    	   }
	    	   
	    	   
	    	  while(linkeListe!=null){
	    		  
	    		 tmp.add(linkeListe.get(0));
	    		 linkeListe.remove(0);
	    		  }
	    	  
	    	  while(rechteListe!=null){
	    		  
		    		 tmp.add(rechteListe.get(0));
		    		 rechteListe.remove(0);
		    		  }
	    	  
	    	   return tmp;	    
	    	
	    	
	    }
}