Datentypen Inhalt zum Iterator wieder aufrufen?

[btl1000]

Hallo,

vorab als Hintergrund: Ich hab vor x Jahren mal C und Delphi und so etwas gelernt und dann 15 Jahre nichts mehr in dem Bereich gemacht. Durch widrige Umstände soll ich nun Java-Programmierbeispiele kurzfristig liefern und stehe ziemlich auf dem Schlauch. Für eine vernünftige Einarbeitung fehlt mir leider effektiv die Zeit, so dass ich mit meinem Halbwissen ein bisschen herumdilettiere und anhand "Java ist auch eine Insel" zumindest ein lauffähiges Beispiel zum Thema TreeTables zusammenbekommen muss.

An folgendem hänge ich nun schon sehr lange fest:

Ich möchte einen zusammengesetzten Datentyp Adresse in einer TreeMap oder HashMap verwalten. Dazu gehört auch, dass ich ab und zu einfach durch alle Elemente iterieren und die Inhalte sehen möchte. Doch bereits daran scheine ich zu scheitern. Vielleicht hat ja jemand den entscheidenden Hinweis zu folgendem Code:

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;

public class Example2_1 {
	public static void main(String[] args) {
		Adresse a = new Adresse("","","","");
		
		Collection<Adresse> adressliste =  new LinkedList<Adresse>();

		// Beispieldaten einfüllen
		adressliste.add(new Adresse("A","2","3","4"));
		adressliste.add(new Adresse("B","2","3","4"));
		adressliste.add(new Adresse("C","2","3","4"));
		adressliste.add(new Adresse("D","2","3","4"));

		// Jetzt einfach wieder ausgeben
		for ( Iterator<Adresse> i = adressliste.iterator();  i.hasNext(); )
		{
			a =  adressliste.get(i);
			System.out.println(a);
			i.next();
		}	
	}
}

Adresse wird hier angelegt:

public class Adresse {
		String vorname;
		String nachname;
		String strasse;
		String ort; 
		
	
	
	Adresse (String vn, String nn,  String st, String or)
	{
		vorname = vn;
		nachname = nn;
		strasse = st;
		ort = or;
	}
	
		
	
		
		
		public String toString()
		{
			return vorname+", "+nachname+"; "+strasse+", "+ort;
		}
	
}

So wie es da steht kompiliert es nicht. Irgendwie verstehe ich nicht, wie ich vom Iterator i wieder zum iterierten Objekt zurückkomme.

 

[musiKk]

vorab als Hintergrund: Ich hab vor x Jahren mal C und Delphi und so etwas gelernt und dann 15 Jahre nichts mehr in dem Bereich gemacht. Durch widrige Umstände soll ich nun Java-Programmierbeispiele kurzfristig liefern und stehe ziemlich auf dem Schlauch. Für eine vernünftige Einarbeitung fehlt mir leider effektiv die Zeit, so dass ich mit meinem Halbwissen ein bisschen herumdilettiere und anhand "Java ist auch eine Insel" zumindest ein lauffähiges Beispiel zum Thema TreeTables zusammenbekommen muss.

Wo wird man denn solchen "widrigen Umständen" ausgesetzt?

So wie es da steht kompiliert es nicht. Irgendwie verstehe ich nicht, wie ich vom Iterator i wieder zum iterierten Objekt zurückkomme.

Es sollte schon kompilieren. Die Methode [c]next()[/c] des Iterators liefert das Objekt. Also [c]Adresse foo = i.next();[/c].

 

[NattleBet]

for (Iterator<Adresse> i = adressliste.iterator(); i.hasNext(); a = i
				.next()) {
	System.out.println(a);
}

 

[btl1000]

Wo wird man denn solchen "widrigen Umständen" ausgesetzt?

Nennen wir die Umstände verkürzt mal "Arbeitsmarkt"

Danke

 

[tommysenf]

Benutze lieber die foreach Schleife:

for(Adresse i : addressliste) {
    System.out.println(i);
}

oder die gute alte while Schleife:

Iterator<Adresse> i = adressliste.iterator();
while(i.hasNext()) {
     System.out.println(i.next());
}

 

[fastjack]

Zur ersten Schleife ist zu sagen, das Du nur read-only Zugriff hast.

 

[btl1000]

Danke an alle, bin jetzt schon mal einen Schritt weiter...

... und habe noch eine Frage (sorry, wenn das so schrittweise durchkleckert, aber allzuviel muss ich auch nicht mehr schaffen ;-)

Jetzt will ich natürlich auch den Kollisionsfall darstellen. Dazu habe ich die hashCode-Funktion entsprechend vereinfacht (verschlechtert), so dass nur der Nachname als Merkmal benutzt wird, um bewusst Gleichheiten zu erzeugen:

public class Adresse {
		String vorname;
		String nachname;
		String strasse;
		String ort; 
		
	
	
	Adresse (String vn, String nn,  String st, String or)
	{
		vorname = vn;
		nachname = nn;
		strasse = st;
		ort = or;
	}
	
		
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Adresse other = (Adresse) obj;
		if (nachname == null) {
			if (other.nachname != null)
				return false;
		} else if (!nachname.equals(other.nachname))
			return false;
		}


	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((nachname == null) ? 0 : nachname.hashCode());
		return result;
	}

		public String toString()
		{
			return vorname+", "+nachname+"; "+strasse+", "+ort;
		}
	
}

und dann rufe ich es ab:

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.Map;

public class Example2_1 {
	public static void main(String[] args) {
		Adresse a = new Adresse("","","","");
		Adresse b = new Adresse("","","","");

		Collection<Adresse> adressliste =  new LinkedList<Adresse>();
		Map< Integer , Adresse> adlhash = new HashMap< Integer , Adresse>();
		
		
		// Beispieldaten einfüllen
		adressliste.add(new Adresse("Alerich","Amann","3","4"));
		adressliste.add(new Adresse("Berta","Bfrau","3","4"));
		adressliste.add(new Adresse("Charlie","Code","3","4"));
		adressliste.add(new Adresse("Dieter","Amann","3","4"));

		// Jetzt einfach wieder ausgeben und dabei in einer Hash-Tabelle abspeichern
		for ( Iterator<Adresse> i = adressliste.iterator();  i.hasNext(); )
		{
			a = i.next(); 
			System.out.println("Adding HashCode "+a+" > "+a.hashCode());
			adlhash.put(a.hashCode(), a);
		}	

		// Jetzt wieder abrufen
		a = new Adresse("A","Amann","3","4");
		b = adlhash.get(a.hashCode());

		System.out.println("Suche "+a.hashCode()+" = "+b);
	
	}
}

Das Ergebnis ist erwartungsgemäß, dass er einen der beiden Treffer anzeigt.

Jetzt sollte er mir als "Bucket" ja eigentlich eine Liste von mehreren Treffern liefern. Angeblich ist das ja standard. Bloß jetzt habe ich nicht den Hauch einer Ahnung, wie ich an diese Ergebnisliste komme. Das Ergebnis ist ja schließlich nur ein Objekt vom Typ Adresse und nicht wieder eine Liste.

Wo geht's da weiter?

Danke im Voraus

 

[btl1000]

Jetzt habe ich gerade gesehen, dass er offenbar bereits beim Hinzufügen eines weiteren Wertes mit dem gleichen Key den alten Wert einfach überschreibt, statt einen weiteren anzuhängen.

Frage: Heißt dass, dass ich die Kollisionsbehandlung selbst bauen müsste, also insbesondere put entsprechend aufbohren im Sinne von "Wenn Key schon vorhanden, dann hänge Wert in einer Collection zu diesem Key an"? Das würde ja auch bedeuten, dass ich als Value immer eine Liste von Adressen nehmen müsste statt einer Adresse selbst.

Seh ich das richtig, oder gibt es das schon im Standard irgendwo fertig und ich habe es bloß nicht gefunden?

 

[fastjack]

Dein Hashcode sollte alle Attribute in betracht ziehen, um eine Kollision zu vermeiden, nur Nachname ist ein bisschen wenig bei einer Adresse. Equals genauso, auf alle relevanten Attribute einer Adresse. Dann gehts.

 

[btl1000]

Dein Hashcode sollte alle Attribute in betracht ziehen, um eine Kollision zu vermeiden, nur Nachname ist ein bisschen wenig bei einer Adresse. Equals genauso, auf alle relevanten Attribute einer Adresse. Dann gehts.

Hmm.. aber dann bekomme ich ja keine Kollision hin.

Ich möchte ja gerade den Fall simulieren, dass die HashCode-Funktion zu schwach ist. Ich will also gerade den Fall provozieren, dass zu einem Hash mehr als ein Eintrag exisitiert. Im Buch war es eben so beschrieben, dass man denn eben statt eines Objektes eine Liste von gleichartigen Objekten zurückgibt. Jetzt ist ja nur die Frage, ob das schon implemntiert ist (wo?) oder ob ich das schön selbst implementiere.

 

[fastjack]

ahso, hab mich verlesen... Das ist nicht implementiert, du mußt es selber machen.