probleme bei LinkedList

[Gast]

Hallo,

ich möchte ein Wörterbuch als LinkedList nach dem sun-Interface implementieren.

Aber wenn ich mir meinen Code so ansehe, mache ich das glaube ich viel zu kompliziert. Außerdem bekomme ich auch in den Zeilen 58 und 65 das warning: unchecked call to addLAst as a member of the raw type java.util.LinkedList.
Kann mir jemand von euch vielleicht weiterhelfen? Denn ich hab langsam keinen Durchblick mehr!
Danke!

import java.util.LinkedList;

public class Woerterbuch implements WoerterbuchInterface {
	

	public static class Eintrag{
		
		/** Vorgaenger in der Eintragsliste */
		public Eintrag vorgaenger;
		/** Das gespeicherte englische Wort */
		public final String englischesWort;
		/** Das dazugespeicherte deutsche Wort */
		public final String deutschesWort;
                public Eintrag neuerEintrag;
                public Eintrag anfang;
                public Eintrag ende;
                public Eintrag next;
		
		/**
		 * erzeugt einen neuen Woerterbucheintrag
		 * @param englischesWort
		 * @param deutschesWort
		 */
		public Eintrag(final String englischesWort, final String deutschesWort){
			this.englischesWort=englischesWort;
			this.deutschesWort=deutschesWort;
		}
	}

        public Eintrag vorgaenger; 
        public Eintrag anfang;
        public Eintrag ende;
        public Eintrag neuerEintrag;
        public Eintrag next;
        public String englischesWort;
        public String deutschesWort;
        public LinkedList buch1;

	
	/**
	 * erzeugt ein leeres Woerterbuch
	 */
	public Woerterbuch() {
                buch1 = new LinkedList();
                anfang = new Eintrag(englischesWort, deutschesWort);
                ende = new Eintrag(englischesWort, deutschesWort);
                anfang.next = ende;
                ende.next = anfang;
                vorgaenger = anfang;  
        }

	/**
	 * fuegt ans Ende einen neuen Eintrag an
	 */
	public void enter(final String englischesWort, final String deutschesWort) {
                if (vorgaenger.next == ende) {
                        buch1.addLast(neuerEintrag);
                        neuerEintrag.next = ende;
                        ende.next.next = neuerEintrag;
                        ende.next = neuerEintrag;
                        vorgaenger = ende.next; 
                }
                else {
                        buch1.addLast(neuerEintrag);
                        neuerEintrag.next = vorgaenger.next;
                        vorgaenger.next = neuerEintrag;
                        vorgaenger = neuerEintrag;
                }
        }
    
        ...
}

 

[SlaterB]

wenn du Generics verwenden möchtest, dann tue es auch:

public LinkedList<Eintrag> buch1; 
// wieso nicht private?
+
buch1 = new LinkedList<Eintrag>();

ansonsten die Warnungen in Eclipse abschalten (falls du Eclipse verwendest)
oder z.B. überall
@SuppressWarnings("unchecked")

--------------

zu deinem 'glaube ich viel zu kompliziert' kann ich so nicht viel sagen,
70 Zeilen sind doch nicht nicht viel

aber warum verwendest du überhaupt eine LinkedList, wenn du die Einträge schon für sich verlinkst?

eins von beiden reicht doch wohl..

----------

wieso sind in Eintrag Exemplarvariable
public Eintrag anfang;
public Eintrag ende;

was sollen die dort?
scheint mir nicht sinnvoll

gleiche Frage fürs Wörterbuch:
public Eintrag vorgaenger;
public Eintrag neuerEintrag;
public Eintrag next;
klingt nicht nach normal typischen Elementen


---------

if (vorgaenger.next == ende) { 
                        buch1.addLast(neuerEintrag); 
                        neuerEintrag.next = ende; 
                        ende.next.next = neuerEintrag; 
                        ende.next = neuerEintrag; 
                        vorgaenger = ende.next; 
                } 
                else { 
                        buch1.addLast(neuerEintrag); 
                        neuerEintrag.next = vorgaenger.next; 
                        vorgaenger.next = neuerEintrag; 
                        vorgaenger = neuerEintrag; 
                }

in dem kleinen Code-Teil sind schon unnötige Wiederholungen,
mache lieber eine allgemeine Operation

public insertBetween(mehrere Knoten) {
Parameter können auch null sein, Anfang Ende gesonder behandeln usw.
..
}

und dann in allen Logikoperationen nur Aufrufe, ala (für obigen Code von dir)

buch1.addLast(neuerEintrag); 
insertBetween(vorgaenger,neuerEintrag,next); 
// oder so, weiß gar nicht was da los ist

 

[Tobias]

Warum um alles in der Welt benutzt du LinkedList nicht einfach, sondern implementierst es neu?

LinkedList übernimmt doch den ganzen Quatsch wie verweise auf das nächste Item für dich... - alles was du tun mußt, ist deinen Eintrag hinzufügen und glücklich sein.

mpG
Tobias

BTW: Eine Hashtable (aka Dictionary(!)) ist für deinen Anwendungszweck sicher besser geeignet.

 

[Gast]

Danke für die Antworten!

Also habe ich das richtig verstanden, dass es vollkommen reicht, wenn ich das so mache (siehe unten)?
Der Compiler hat nix mehr dran auszusetzen, aber kann ich das so verwenden, um jetzt Methoden wie Eintrag suchen, löschen, ... zu implementieren?

import java.util.LinkedList;

public class Woerterbuch implements WoerterbuchInterface {
	

	public static class Eintrag{
		
		/** Vorgaenger in der Eintragsliste */
		public Eintrag vorgaenger;
		/** Das gespeicherte englische Wort */
		public final String englischesWort;
		/** Das dazugespeicherte deutsche Wort */
		public final String deutschesWort;
               
		
		/**
		 * erzeugt einen neuen Woerterbucheintrag
		 * @param englischesWort
		 * @param deutschesWort
		 */
		public Eintrag(final String englischesWort, final String deutschesWort){
			this.englischesWort=englischesWort;
			this.deutschesWort=deutschesWort;
		}
	}

        public Eintrag vorgaenger; 
        public Eintrag kopf;
        public Eintrag neuerEintrag;
        public String englischesWort;
        public String deutschesWort;
        public LinkedList<Eintrag> buch1;

	
	/**
	 * erzeugt ein leeres Woerterbuch
	 *
	public Woerterbuch() {
                buch1 = new LinkedList<Eintrag>();
                kopf = null;
        }

	
	/**
	 * fuegt ans Ende einen neuen Eintrag an
	 */
	public void enter(final String englischesWort, final String deutschesWort) {
                buch1.addLast(neuerEintrag);
        }

 

[Tobias]

Indem du die weiteren List-Operation wie indexOf(), get() und remove() benutzt. Deine Klasse Woerterbuch hat immer noch obskure Instanzvariablen wie vorgaenger etc. Meditier mal darüber, warum die da stehen und welchen Zweck sie deiner Meinung nach haben.

mpG
Tobias

 

[Guest]

Alles, was in class Eintrag steht, ist mir vorgegeben:
Was ich mit dem vorgaenger anstellen soll, verstehe ich nicht. Meine Liste ist ja schließlich nicht von hinten nach vorne verkettet.

Gib mir doch bitte einen Tip , denn ich hänge da wirklich schon seit Samstag mittag dran und implementier das ganze jetzt zum dritten Mal auf eine dritte Art und Weise, weil es ständig zu unübersichtlich wird und ich Dinge mache, die ich aus C kenne, aber mit dem sun-interface - wie ich so eben gelernt habe - überhaupt nicht nötig sind.

 

[Gast]

Zweck haben die jetzt keinen mehr, hab sie nur vergessen zu löschen.

 

[Gast]

bis auf buch1 und neuerEintrag

 

[Tobias]

Mh, neuerEintrag ist aber auch überflüssig (zum Mal du ihn (wie mir erst jetzt auffällt) gar nicht belegst). Deine enter()-Methode muss so aussehen:

public void enter(final String englischesWort, final String deutschesWort) {
    buch1.addLast(new Eintrag(englischesWort, deutschesWort);
}

Warum vorgaenger in Eintrag steht kann dir meine Glaskugel nicht beantworten, dafür müßte ich mindestens die Aufgabenstellung kennen - bin bislang halt immer davon ausgegangen, dass das hier das erste Projekt eines (freiwilligen) Java-Lerners ist. Denn wie ich bereits anmerkte, halte ich schon die Wahl der zugrundegelegten Collection LinkedList für suboptimal.

Da du tatsächlich schon seit Samstag daran arbeitest (und das anscheinend intensiv - habe bereits deinen letzten Thread gelesen), würde ich sagen, du postest die Aufgabenstellung und ich schaue mal, wo ich dir ein paar hilfreichere Tipps geben kann, ok?

mpG
Tobias

 

[Gast]

OK, super nett von dir, weil langsam verzweifle ich!

AUFGABE:

Die Signatur des ADT Wörterbuch soll wie folgt lauten:
• create: !Wörterbuch
• enter: Wörterbuch x Ew x Dw !Wörterbuch
• find: Wörterbuch x Ew !Dw [ {?}
• delete: Wörterbuch x Ew !Wörterbuch
• concat: Wörterbuch x Wörterbuch !Wörterbuch
Hinweis: Die englischen und deutschenWörter können als ein ADT Wort zusammengefasst werden

Implementieren Sie ADT Wörterbuch als eine
einfach verkette Liste. Hierfür soll das Interface
WoerterbuchInterface.java implementiert werden, das zusätzlich die Klasse Eintrag
enthält, die als Element der Liste verwendet werden soll.
• Die create-Operation soll auf den default-Konstruktor ohne Parameter abgebildet werden.
• Das erste Wörterbuch, das von den restlichen Operationen als Parameter erwartet wird, entspricht
dem Objekt an dem die entsprechenden Methoden aufgerufen werden.
• Die Operationen enter, delete und concat liefern laut Signatur einWörterbuch zurück. In Ihrer
Implementierung soll jeweils das aktuelle Objekt verändert werden.
• Es sollen beide delete-Operationen als void delete(String ew) und void
deleteAll(String ew) implementiert werden.

Das Interface sieht so aus:

public interface WoerterbuchInterface {

       /**
         * Diese Klasse stellt einen Eintrag in dem Woerterbuch dar
         */
         public static class Eintrag{

                /** Vorgaenger in der Eintragsliste */
                public Eintrag vorgaenger;
                 /** Das gespeicherte englische Wort */
                public final String englischesWort;
                 /** Das dazugespeicherte deutsche Wort */
                public final String deutschesWort;

               /**
                * erzeugt einen neuen Woerterbucheintrag
                * @param englischesWort
                * @param deutschesWort
                */
                public Eintrag(final String englischesWort, final String deutschesWort){
                        this.englischesWort=englischesWort;
                        this.deutschesWort=deutschesWort;
                }
        }


/**
 * erzeugt ein leeres Woerterbuch
 */
/*public WoerterbuchInterface();*/



/**
 * fuegt ans Ende einen neuen Eintrag an
 * @param englischesWort
 * @param deutschesWort
 */
public void enter(final String englischesWort, final String deutschesWort);


/**
 * sucht nach dem zuletzt eingefuegten Eintrag, der zum uebergebenen Wort passt
 *  
 * @param englischesWort
 * @return das zum gefundenen Eintrag gehoerende deutsche Wort, oder 
 * <code>null</code>, wenn kein passender Eintrag gefunden wurde
 */
public String find(final String englischesWort);
 

/**
 * loescht den zuletzt eingefuegten Eintrag, der zum uebergebenen Wort passt
 * 
 * @param englischesWort
 */
public void delete(final String englischesWort);


/**
 * loescht alle Eintraege, die zum uebergebenen Wort passen
 * 
 * @param englischesWort
 */
public void deleteAll(final String englischesWort);


/**
 * fuegt alle Eintraege des uebergebenen Woerterbuchs unter beibehalt der 
 * Reihenfolge ein
 * 
 * @param woerterbuch
 */
public void concat(final WoerterbuchInterface woerterbuch);


}

 

[Tobias]

OK. Wie gesagt, LinkedList ist für ein Wörterbuch die falsche Collection, Hashtable (oder eine beliebige andere Map) wäre hier das Mittel der Wahl.

Dein Prof möchte anscheinend, dass du die Liste zu Fuß implementierst - deshalb auch die Variable vorgaenger in Eintrag. Auch das Bullshit, weil du ja gesehn hast, das Java das längst implementiert hat, aber gut...

Ich schreibe dir das Programm, dauert nur eine Minute oder zwei.

BTW: Dein Prof hat keine Ahnung von Java, oder?

Wenn delete: Woerterbuch x eW !Woerterbuch heißen soll, das die Methode delete() der Klasse Woerterbuch ein englischesWort entgegennimmt und ein Woerterbuch zurückliefert, dann kann man als Methodendefinition doch nicht

public void delete(String englischesWort);

in das Interface schreiben!

mpG
Tobias

 

[Tobias]

Und die concat() ist mit diesem Interface gar nicht zu implementieren - ich kriege ja niemals Zugriff auf einen Eintrag des anzuhängenden Wörterbuchs!
Mit der Methodendefinition aus dem Fließtext wäre es zumindest noch mit einem Hack zu bewerkstelligen, aber so?

Unter diesen Umständen muss ich mein Angebot, das Programm zu schreiben leider zurückziehen. Die Unterschiede in Aufgabenstellung und Interface sind schlicht nicht überbrückbar. Die gesamte Aufgabenstellung zeugt von einem bei einem Lehrer erschreckenden Java-Unwissen.

mpG
Tobias *kopfschüttel*

 

[Gast]

Und wenn du die concat einfach weglässt?
Damit ich wenigstens weiß wie das geht, was er will?
Denn wir verbessern die Aufgaben nämlich auch nicht!!!

 

[Tobias]

public class Woerterbuch implements WoerterbuchInterface {
	
	public static Woerterbuch create() {
		return new Woerterbuch();
	}
	
	private Eintrag letzterEintrag;
	
	public Woerterbuch() {
		letzterEintrag = null;
	}
	
	public Woerterbuch(String englischesWort, String deutschesWort) {
		this();
		letzterEintrag = new Eintrag(englischesWort, deutschesWort);
	}

	/* Kann nicht funktionieren.
	 * @see WoerterbuchInterface#concat(WoerterbuchInterface)
	 */
	public void concat(WoerterbuchInterface woerterbuch) {
		/* Beschaffe eine beliebige Eintrag-Instanz aus dem
		 * übergebenen Wörterbuch, traversiere die Liste bis zum
		 * ersten Eintrag (mit vorgaenger == null) und setze den
		 * Vorgaenger dieses Eintrags auf this.letzterEintrag.
		 */
	}

	/*
	 * @see WoerterbuchInterface#delete(java.lang.String)
	 */
	public void delete(String englischesWort) {
		Eintrag nachfolger = null;
		Eintrag aktueller = letzterEintrag;
		
		while(aktueller != null) {
			if(aktueller.englischesWort.equals(englischesWort)) {
				if(nachfolger != null) {
					nachfolger.vorgaenger = aktueller.vorgaenger;
					return;
				}
			}
			
			nachfolger = aktueller;
			aktueller = aktueller.vorgaenger;
		}
	}

	/*
	 * @see WoerterbuchInterface#deleteAll(java.lang.String)
	 */
	public void deleteAll(String englischesWort) {
		Eintrag nachfolger = null;
		Eintrag aktueller = letzterEintrag;
		
		while(aktueller != null) {
			if(aktueller.englischesWort.equals(englischesWort)) {
				if(nachfolger != null) {
					nachfolger.vorgaenger = aktueller.vorgaenger;
				}
			}
			
			nachfolger = aktueller;
			aktueller = aktueller.vorgaenger;
		}
	}

	/*
	 * @see WoerterbuchInterface#enter(java.lang.String, java.lang.String)
	 */
	public void enter(String englischesWort, String deutschesWort) {
		Eintrag neuerEintrag = new Eintrag(englischesWort, deutschesWort);
		Eintrag alterLetzterEintrag = letzterEintrag;
		letzterEintrag = neuerEintrag;
		neuerEintrag.vorgaenger = alterLetzterEintrag;
	}

	/*
	 * @see WoerterbuchInterface#find(java.lang.String)
	 */
	public String find(String englischesWort) {
		Eintrag eintrag = letzterEintrag;
		
		while(eintrag != null) {
			if(eintrag.englischesWort.equals(englischesWort)) {
				return eintrag.englischesWort;
			}
			eintrag = eintrag.vorgaenger;
		}
		
		//Nix gefunden
		return null;
	}
	
	//Nur zum Testen
	public static void main(String[] args) {
		Woerterbuch wb = Woerterbuch.create();
		wb.enter("Java", "Java");
		wb.enter("is", "ist");
		wb.enter("cool", "super");
		wb.enter("PHP", "PHP");
		wb.enter("is", "ist");
		wb.enter("a big fuck-up", "eine ganz große Scheiße");
		
		System.out.println(wb.find("Java"));
		System.out.println(wb.find("is"));
		System.out.println(wb.find("cool"));
		
		wb.delete("PHP");
		if(wb.find("PHP") == null) {
			System.out.println("PHP gelöscht!");
		}
		else {
			System.out.println("Das ist schiefgegangen!");
		}
		
		wb.deleteAll("is");
		if(wb.find("is") == null) {
			System.out.println("Alle Vorkommen von is gelöscht!");
		}
		else {
			System.out.println("Das ist schiefgegangen!");
		}
	}

}

Wenn dir was im Code unklar ist, frag. Ich hatte keine Lust, alles ausführlich zu kommentieren, weil ich annehme, dir da in 80% der Fälle nur altbekanntes wiederzukäuen. Bei der concat() hab ich jetzt mal hingeschrieben, wie ich mir vorstelle, dass man sie implementieren sollte.

mpG
Tobias

 

[Tobias]

Ups, kleiner peinlicher Fehler (der beim Testen hätte auffalen müssen):

Die Methode find() muß natürlich eintrag.deutschesWort zurückliefern und nicht eintrag.englischesWort!

mpG
Tobias

 

[Gast]

Also erst mal ein megariesengroßes Dankeschön!!! :toll:
Ohne dich hätte ich das nicht mehr hinbekommen!!

Was jetzt nur noch nicht funktioniert, ist deine Zeile 4.
Da sagt mir der Compiler Woerterbuch is abstract and cannot be instantiated.

Und eine Frage hab ich noch: Wo ist der Unterschied zwischen den Methoden delete() und deleteAll() ?

 

[Gast]

Ich kapier das noch nicht ganz mit concat().

Kannst du mir vielleicht da noch mal helfen? Ich versuch das jetzt mal so anstatt mit WoerterbuchInterface:

        public void concat(final WoerterbuchInterface woerterbuch) {
                //und hier WoerterbuchInterface als Woerterbuch casten, nur ich hab keine Ahnung wie,
                //denn die mir bekannte Methode der Typkonvertierung: " (Woerterbuch) woerterbuch " 
                //funktioniert nicht
        }

 

[Gast]

Doch! So funktionierts!

        public void concat(final WoerterbuchInterface woerterbuch) {
                Woerterbuch woerter_buch = (Woerterbuch) woerterbuch;      
        }

 

[Tobias]

Hat sich der Fehler in Zeile 4 erledigt?

Zu deiner concat-Methode: Gut, aber zusammengefügt (konkateniert) hast du die beiden Wörterbücher dadurch ja nicht. Die einzige Lösung wäre entweder das Interface abändern oder statt WoerterbuchInterface ein Woerterbuch übergeben und in Woerterbuch eine entsprechende Methode zum Zugriff auf letzterEintrag einbauen - die muss ja nicht public sein, sondern da reicht package-Zugriff.

mpG
Tobias

 

[Tobias]

delet() kehrt zurück, sobald der erste Beitrag gelöscht wurde, der das gesuchte Wort enthält. deleteAll() löscht alle Beiträge mit dem gesuchten Wort. Nur aus didaktischen Gründen habe ich darauf verzichtet, das eigentliche Löschen in eine private-Methode auszulagern.

mpG
Tobias