# Key-Value-Objekte in Map



## Sindbad1983 (4. Mrz 2005)

Hi!

Da bin ich wieder!  :### 



Es geht um folgendes Problem : Ich möchte eine Klasse Map für die Darstellung von mathematischen Abbildungen entwickeln. Die Definition von Abbildungen erfolgt dabei durch explizite Angabe der Paare Argument und Wert.

Key    Value

"A"       "a"
"B"       "b"
"C"       "c"
"D"       "b"
....        ....

Die Einträge Argument (Key) und Wert(Value) sollen in einer verketteten Liste (zu implementieren mit einer LinkedList) verwaltet werden. Für Key und Value können beliebige Objekte (Typ Object) verwendet werden. Der Test auf Gleichheit von Key- und Value-Objekten soll mit equals erfolgen!

Naja, und dann sollen eben für Map-Objekte verschiedene Operationen zur Verfügung stehen:
z.B. Anfügen von neuen Einträgen (Key-Value-Paar)-> für ein Argument (Key) darf nur ein einziger Wert(Value) definiert sein!
dann Löschen von Einträgen
Zugriff auf den Wert(Value) für ein Argument (Key) und so weiter halt!

Nur weiß ich momentan absolut nicht, wie ich an das Problem herangehen soll!
Ich glaub, mit einer Hash Map würd es am einfachsten funktionieren, aber die dürfen wir glaub ich nicht verwenden (-> Linked List)!

Kann mir da jemand ein paar Tipps zum Einstieg geben bitte.    
Wieviele Klassen werd ich da brauchen?
Ich hab jetzt schon mal die Schnittstellen definiert, aber ....  :cry: 

Danke,
ciao


----------



## mic_checker (4. Mrz 2005)

Also das hört sich ja schon mal gar nicht so schlecht an.

Wurde dir vorgegeben das du das ganze in einer Verketteten Liste realisieren sollst (also ohne HashMap) ? 

Ansonsten musst du dir halt deine eigene Klasse definieren. Diese beinhaltet als Variablen key und value und die typischen get/set Methoden. Dabei ist wichtig das du die Regeln für Abbildungen einhälst, also z.B. einem x keine zwei y zuweist.

Um sicherzustellen das einem Key nicht mehrere y zugeordnet werden könntest du vielleicht HashSet verwenden (wenn das erlaubt ist).

Wie man mit LinkedList arbeitet weisst du?



> Ich glaub, mit einer Hash Map würd es am einfachsten funktionieren, aber die dürfen wir glaub ich nicht verwenden


Ja - mit einer HashMap ging es wohl ziemlich schnell.


----------



## Sindbad1983 (4. Mrz 2005)

danke für deine schnelle Antwort!

Mit einer LinkedList hab ich leider noch nie gearbeitet!Muss ich mir noch anschaun!Wird aber hoffentlich wohl ähnlich einer ArrayList sein!

Nein, Hash Map dürfen wir nicht verwenden!

Ja keine Ahnung, das ist die Angabe...ich denk mal schon, dass wir eigene Klassen entwickeln sollen!Gibt ja dann wohl keine andere Möglichkeit, oder?
Also brauch ich nur 1 Klasse oder? 
HashSet kenn ich überhaupt nicht!Denk nicht, dass das erlaubt ist! :-(

danke!!


----------



## bygones (4. Mrz 2005)

ArrayList und LinkedList sind im grunde ähnlich, beide implementieren das Interface List.

Aufpasse solltest du aber, da du bei ArrayList indexbasiert auf die Werte zugreifen kannst (list.get(5)) - was aber bei einer LinkedList verherrend ist.

Warum ? Die ArrayList ist intern ein Array (haha...) daher ist der indexbasierte Zugriff sehr schnell. LinkedList ist eine verkette Liste die nur über referenzen auf die nächsten Element verweist. D.h. ein indexbasierter Zugriff erfordert immer einen kompletten Lauf vom ersten Element an bis der gg,. index erreicht ist.

Ich würde eine Klasse mit 2 variablen nehmen (key / value). die werden in der LinkedList gespeichert. wenn neue Elemente eingefügt werden musst du jhalt die Liste durchlaufen (iterieren) und überprüfen ob es ein Element mit dem bestimmten key schon gibt. wenn ja übschreiben, wenn nein einfügen....


----------



## mic_checker (4. Mrz 2005)

deathbyaclown hat gesagt.:
			
		

> Ich würde eine Klasse mit 2 variablen nehmen (key / value). die werden in der LinkedList gespeichert. wenn neue Elemente eingefügt werden musst du jhalt die Liste durchlaufen (iterieren) und überprüfen ob es ein Element mit dem bestimmten key schon gibt. wenn ja übschreiben, wenn nein einfügen....



Da ist natürlich noch die Frage ob er den Wert denn überschreiben will. Aber das muss er natürlich selber entscheiden - kann ja sein das bei der Berechnung der Funktionswerte ein Fehler aufgetreten ist und deswegen dem x ein "falsches" y zugeordnet wird...wobei dieses x eigentlich schon ein "korrektes" y hat....

Ansonsten würde ich noch nachfragen ob du HashSet verwenden darfst, ist recht einfach in der Anwendung.

Ist zwar ein anderes Thema, aber hier habe ich eine Möglichkeit gepostet eine Lotterie-Ziehung mit u.a. HashSet zu realisieren:
http://www.java-forum.org/de/viewtopic.php?t=13722&highlight=lotto

Hier der relevante Code:


```
import java.util.*;

public class Lotto1
{
   public static void main(String[] args)
   {
      int zahl,count = 0;
      HashSet lotto = new HashSet();      
      Random gen = new Random();
      
      /* Es sollen 6 Zahlen gezogen werden */
      while(count < 6)
      {
         /* 0 ist nicht erwünscht */
         do
         {
            zahl = gen.nextInt(50);
         }while(zahl == 0);
         
         if(!lotto.add(new Integer(zahl)))
            continue;
         
         System.out.println(++count+".Zahl = "+zahl);         
      }
         
   }
}
```

Schau dir dazu auch mal 
http://java.sun.com/j2se/1.5.0/docs/api/java/util/HashSet.html

an.


----------



## Sindbad1983 (7. Mrz 2005)

Hi!

Ich weiß einfach nicht, wie ich die beiden Werte in die Liste speichern soll, bzw. wie man weiß, dass das jeweilige Key-Value Paar zusammen gehört!?!
Ich mein, die Werte muss ich ja nur mit add und remove der Liste hinzufügen bzw. entfernen, nachdem ich geprüft habe, ob der Key Wert schon mal vorkommt, aber ... :cry: 

Naja, es könnte vielleicht wie gesagt mit set und get-Methoden gehn!
Dass ich mit set einen Value zum jeweiligen Key setze, und dann mit get den Wert wieder auslese! Oder ist das falsch?
Kann mir jemand vielleicht ein kleines Beispiel geben bitte?


----------



## Wildcard (7. Mrz 2005)

DBAC hat gesagt.:
			
		

> Ich würde eine Klasse mit 2 variablen nehmen (key / value). die werden in der LinkedList gespeichert. wenn neue Elemente eingefügt werden musst du jhalt die Liste durchlaufen (iterieren) und überprüfen ob es ein Element mit dem bestimmten key schon gibt. wenn ja übschreiben, wenn nein einfügen....


Einfach so:

```
public class KeyValuePairs
{
        private Object key,value;

        public KeyValuePairs(Object key, Object value)
        {
            this.key=key;
            this.value=value;

        }
}
```
dazu Getter und Setter, und diese Elemente dann in deine Liste einfügen


----------



## Sindbad1983 (8. Mrz 2005)

So, ich hab das jetzt ein wenig ausgebaut, weiß aber nicht genau, ob das jetzt mal so in etwa stimmt:


```
public class KeyValuePairs{

	private Object key,value;
	private boolean isInList;

	public KeyValuePairs(Object key,Object value){
		this.key=key;
		this.value=value;
	}

	public Object getValue(Object key){
		return value;
	}

	public Object getKey(Object value){
		return key;
	}

	//ist Key in Liste schon enthalten?  oder muss ich da mit equals vergleichen? 
	public boolean contains(Object key){
		return isInList;
	}

	public String toString(){
		.
		.
		return...
	}
	

    public void remove(Object key){
    .
    .
    }
	
                //soll ein Array mit allen Key-Werten zurückgeben
	public Object [] toArray(){
		return ..
	}
}
```


```
import java.util.*;

public class TestKeyValue{


	public static void main(String [] args){

                               
		LinkedList list=new LinkedList();

		list.add(new KeyValuePairs("A","a"));

		Iterator it=list.iterator();
                                    while(it.hasNext..
                                    .
                                    .
                                    .

	}

}
```

Also ich muss wohl die Liste mit einem Iterator durchlaufen, oder?
Aber darf ich das list.add(new...) überhaupt so verwenden?
Wenn ich bei remove key=null setze, dann müsste ja eigentlich value auch weg(null) sein, oder? Hab ich da einen Denkfehler?
Und wenn ich nun einen Key-Wert auslesen möchte, wie ruf ich den überhaupt auf?
mit z.B.: list.getKey("A") ?? 

Außerdem wirft er mir folgenden Fehler aus:
Note: C:\Studium\TestKeyValue.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Prozess erfolgreich beendet.

Maa,ich glaub ich bin echt weit weg! :cry: 

Danke für eure Hilfe!


----------



## Wildcard (8. Mrz 2005)

Du mischst da Sachen die nicht zusammen gehören:
Die Klasse KeyValuePairs soll nicht deine Liste werden.
Die besteht nur aus Getter und Settern.
Für deine Liste brauchst du eine eigene Klasse die KeyValuePairs erstellt und sie in sich einfügt.
Die Warnung kommt weil du mit Java 5 Collections nicht ohne Generics verwenden solltest.


----------



## Sindbad1983 (8. Mrz 2005)

ja, du hast Recht...also nochmal ganz von vorn:

ich brauch folgende Klassen:

KeyValuePairs:

Object key
Object value
setKey(Object key)
getKey()
setValue(Object value)
getValue()

------ 
Verwaltung:
LinkedList():list
add()
remove()
contains()
size()
toString()

------

Test:
mit der main-Methode


Stimmt das jetzt in etwa so?


----------



## Wildcard (8. Mrz 2005)

Sindbad1983 hat gesagt.:
			
		

> Stimmt das jetzt in etwa so?


Sieht ganz vernünftig aus.
Mach für KeyValuePairs einen Konstruktor bei dem direkt Key und Value übergeben werden können.


----------



## Sindbad1983 (8. Mrz 2005)

ja aber das stimmt schon oder?


```
LinkedList list=new LinkedList(); 

      list.add(new KeyValuePairs("A","a"));
```


da leg ich ja im ersten Knoten der Liste gleich ein KeyValue-Objekt an!
Aber wie kann ich dann auf z.B.den Key "A" innerhalb der Liste zugreifen???
Die Methode getKey ist ja nur in KeyValuePairs definiert??
Weißt du, was ich mein?
mit list.getKey sicher nicht oder?


----------



## Wildcard (8. Mrz 2005)

Du läufst die Liste durch, schaust dir die Key's an, und gibst den entsprechenden Value zurück.
Ist nicht die perfomantest Methode, aber sicher die einfachste. Da das ja vermutlich nur eine Übungsaufgabe ist...


----------



## Sindbad1983 (8. Mrz 2005)

danke dass du immer so schnell antwortest! 
Aber ich steh grad echt vollkommen auf der Leitung! :-(


soll ich die Liste mit einem Iterator durchlaufen?
und in welcher Klasse soll ich das machen? in Verwaltung oder in Test?
und wenn ich jetzt die Liste durchlaufe

z.B.

"A"  "B"  "C"  "D"
"a"  "b"          "s"

wie erkennt er dann, dass genau bei "C" kein Value-Wert ist?




oh Mann, ich bin grad echt verwirrt! :autsch: 
Tut mir leid! :cry:


----------



## Wildcard (8. Mrz 2005)

Also stell dir das so vor:
Du hast eine Klasse Key/ValuePairs
eine Klasse MyMap die so eine Art Hashmap mit LinkedList simuliert, und
eine Klasse TestMap die MyMap verwenden soll.
TestMap erstellt eine MyMap und fügt darin Key/Value Paare ein.
MyMap macht daraus KeyValuePairs und setzt sie in die linkedList (die auch nur intern bekannt ist).
TestMap will jetzt den Wert zum Schlüssel 'B' haben.
Also 

```
myMap.get(B);
```
MyMap geht jetzt mit einem Iterator über die interne linkedList und holt sich so jedes KeyValuePair.
Bei den KeyValuePairs vergleicht es den Key mit dem von TestMap gewünschten und gibt dann bei übereinstimmung den entsprechenden Value zurück.


----------



## mic_checker (8. Mrz 2005)

Vielleicht könntest du auch mal deinen bisherigen Code posten, so ist es einfacher konkret auf das Problem einzugehen.
Also ich meine den neuen Code mit der neuen Struktur..


----------



## Sindbad1983 (8. Mrz 2005)

ok..werd ich morgen machen!

Hab gar nicht gewusst, dass es "Aufgaben und Gesuche" auch gibt!  

Bis morgen!
Danke!
ciao


----------



## Sindbad1983 (9. Mrz 2005)

> eine Klasse MyMap die so eine Art Hashmap mit LinkedList simuliert, und
> eine Klasse TestMap die MyMap verwenden soll.



Hash Map darf ich leider nicht verwenden!und ich muss eine eigene Klasse LinkedList erstellen!  :bahnhof: 


Ich hab mir die Konzeption jetzt nochmal durch den Kopf gehen lassen!

Also ich hab eine Klasse Map, eine Klasse KeyValuePair und eine Klasse LinkedList!

Die Klasse KeyValuePair ist klar: die hamma eh schon:




```
public class KeyValuePair{
	
	private Object key;
	private Object value;
	
	public KeyValuePair(Object key,Object value){
		this.key=key;
		this.value=value;
	}
	
	
	
}
```


dann hab ich noch folgende Funktionen: (Schnittstellen)

1.//Einfügen eines Key/Value-Pair
public void add(Object key,Object value){}

2.//Löschen eines Key/Value-Pair
public void  delete(Object key){}

3.//Abfragen eines Values für einen Key
public Object getValue(Object key){}

4.//Abfragen aller keys
public Object [] getDomain(){}

//Konstruktor
public Map(){} ->das gehört in die Klasse Map...das ist klar!

Aber wohin würdest du diese Methoden hineingeben?
in die Klasse Map oder in die Klasse LinkedList?

Für mich ist es irgendwie logischer, wenn Einfügen und Löschen oder z.B.:getValue  in der Klasse LinkedList implementiert werden, weil ich da ja direkt Zugriff auf die Liste hab, oder?
Oder würdest du die alle in Map implementieren?  ???:L  

Das ist mal das grundlegende Problem, das ich  klären muss! :?: 

Und brauch ich eine 4.Klasse (TestMap) auch noch unbedingt?

Danke!


----------



## Wildcard (9. Mrz 2005)

Sindbad1983 hat gesagt.:
			
		

> Hash Map darf ich leider nicht verwenden!und ich muss eine eigene Klasse LinkedList erstellen!


Das du keine Hashmap verwenden darfst ist mir klar. Die sollst du ja quasi "nachbauen".
Hab dich aber zuerst so verstanden das du das mit einer LinkedList machen sollst, nicht das du eine eigene LinkedList erstellen sollst???
Falls ich damit richtig liege kommen alle Methoden die die unten aufgeführt hast in deine MyMap Klasse.
Ein aussenstehender braucht nicht zu wissen wie du das intern machst, und weiß daher auch gar nichts von einer LinkedList.


----------



## Sindbad1983 (9. Mrz 2005)

ja..ich muss eine eigene Klasse LinkedList erstellen!
Was da rein soll, weiß ich momentan noch nicht!

Ok..ich versuch jetzt, dass ich mal die unten oben angeführten Methoden in Map implementiere!
obwohl ichs in der Klasse LinkedList logischer finden würde!  :autsch: 

Soll ich die Liste mit einem Iterator durchlaufen oder einfach

Node n;
Node current,next;

if(this.key!= key){
    n=key;
}
else{
    n=n.next;
}

..oder so ähnlich...muss ich mir noch überlegen!


----------



## Wildcard (9. Mrz 2005)

Du sollst deine eigene LinkedList erstellen, und daraus deine eigene Map machen? Was ist denn das für eine seltsame Aufgabe? Welche Datenstrucktur soll dahinter stehen? Musst du etwa bis auf Array runter????


----------



## Sindbad1983 (9. Mrz 2005)

baa, ich glaub ich weiß selber nicht ganz, was da gemeint ist! 

Entwickeln Sie eine Klasse Map für die Darstellung von mathematischen Abbildungen. Die Definition von
Abbildungen erfolgt dabei durch explizite Angabe der Paare Argument und Wert.

Key Value
"A" "a"
"B" "b"
"C" "c"
"D" "b"
… …

Die Einträge Argument (im Folgenden Key) und Wert (im Folgenden Value) sollen in einer verketteten
Liste verwaltet werden. Für Key und Value können beliebige Objekte (Typ Object) verwendet werden.
Der Test auf Gleichheit von Key- und Value-Objekten soll mit equals erfolgen.

Für Map-Objekte sollen folgende Operationen zur Verfügung stehen:

 Anfügen von neuen Einträgen (Key-Value-Paar). Beachten Sie, dass für eine Argument (Key,
Gleichheit definiert durch equals!) nur ein einziger Wert (Value) definiert sein kann.
 Löschen von Einträgen.
 Zugriff auf den Wert (Value) für ein Argument (Key).
 Testen, ob für ein bestimmtes Argument (Key) ein Wert (Value) definiert ist.
 Zugriff auf den Definitionsbereich (alle Keys). Dieser soll als Objektarray geliefert werden.
Übung Softwareentwicklung 2 SS 2005
 Zugriff auf den Wertebereich (alle Values). Diese sollen ebenso als Objektarray geliefert werden.
 Eine Methode public String toString(), welche eine lesbare String-Repräsentation der
Abbildung liefert.
 Eine Methode public boolean equals(Map m), die diese Abbildung mit der Abbildung m
auf Gleichheit testet.
 Eine Methode public Map concatenate(Map m), welche die Konkatenation dieser Abbildung
mit der Abbildung m berechnet und die resultierende Abbildung liefert.


Achten Sie besonders auf die Gestaltung der öffentlichen Schnittstelle der Klasse Map. Implementieren Sie
die Klasse Map unter Verwendung einer verketteten Liste (die Sie auch selbst implementieren sollen).

Realisieren Sie eine Testklasse für die Klasse Map, in der Sie für jede öffentliche Methode von Map eine
eigene Testmethode schreiben. 

...so schauts aus, damit du mal die Angabe kennst
ich denk schon, dass ich eine eigene Klasse LinkedList erstellen muss

Naja...für Map-Objekte sollen folgende Operationen zur Verfügung stellen..das heißt wohl schon, dass ich diese Funktionen wie du richtig gesagt hast, in Map erstellen muss!


----------



## Wildcard (9. Mrz 2005)

Wirklich etwas seltsam. Das sagt immer noch sehr wenig aus welcher Datentyp verwendet werden darf.
Arrays, ArrayList, Vector? Muss ich mal kurz drüber nachdenken


----------



## Sindbad1983 (9. Mrz 2005)

naja, wie gesagt..er hat gemeint LinkedList sollen wir verwenden..und dazu eine eigene Klasse erstellen!
Mensch, das ist echt eine schei*** Übung!


----------



## Wildcard (9. Mrz 2005)

Aber was soll man denn an LinkedList noch ändern?


----------



## Sindbad1983 (9. Mrz 2005)

:###


----------



## Wildcard (9. Mrz 2005)

Seh ich 2 Möglichkeiten:
1. Du fragst nochmal nach was diese eigene Implementierung von LinkedList bedeuten soll(weil ich wüsste nicht was man da noch machen soll)
2. Du ignorierst das einfach  :wink:


----------



## Sindbad1983 (9. Mrz 2005)

:lol: 

ja, das stellt mich auch vor Rätsel;

keine Ahnung..das darfst du mich nicht fragen! 
Ich bin jetzt komplett verwirrt! :cry: 

Du musst dich aber heut nicht mehr mit meinem Problemen herumschlagen!
Ich will dir nicht deinen Abend vermiesen!
Oh die Bayern spielen!  :bloed:


----------



## Sindbad1983 (9. Mrz 2005)

ok..ich ignoriers

ich werd dann einfach sagen

LinkedList pairs=new LinkedList();


----------



## Wildcard (9. Mrz 2005)

Sindbad1983 hat gesagt.:
			
		

> ok..ich ignoriers


 
Ich versteh eh nicht ganz warum er/sie eine LinkedList verwenden will.
ArrayList würde sich hier deutlich besser eignen da es einen schnellen Zugriff über Indizes erlaubt, was hier ideal währe. Aber naja...
Was hast du bis jetzt und wo hängst du noch?


----------



## Sindbad1983 (9. Mrz 2005)

naja..ich weiß einfach nicht, wo da jetzt die LinkedList hingehört!

Und wie ich die dann durchlaufen soll, damit ich Zugriff auf key hab!
Ich hab da seit 2 Tagen eine geistige Blockade glaub ich!  :cry: 


```
public class KeyValuePair{

	private Object key;
	private Object value;

	public KeyValuePair(Object key,Object value){
		this.key=key;
		this.value=value;
	}
}
```


```
public class Map{
	
	
	LinkedList pairs=new LinkedList(); //gehört das da rein?
	
	
	int nElems; //Anzahl KeyValuePair in Map
	
	public Map(){
		Map map=new Map();	
		nElems=0;
	}
	
	
	public boolean add(Object key,Object value){
		
	}
	
	
	public void delete(Object key){
	}
	
	
	
	public Object getValue(Object key){
	}
	
	
	
	
	public Object [] getDomain(){
	}
	
}
```


----------



## Wildcard (9. Mrz 2005)

Hab ein Beispiel gemacht: 
Wenn ein key schon vorhanden ist, bleibt der alte Wert und die Methode liefert false.
Wusste nicht ob der alte Wert überschrieben werden soll.

```
public class Map
{
    private final LinkedList list = new LinkedList();
    
    public boolean add(Object key, Object value)
    {
        if (contains(key))
            return false;    
        return list.add(new KeyValue(key,value));
    }
    
    public boolean contains(Object key)
    {
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            if (((KeyValue)it.next()).getKey().equals(key))
                return true;
        }
        return false;
    }
}
```


----------



## Sindbad1983 (9. Mrz 2005)

boa...danke! 
Das ist super!
Das versteh ich!Spitze!

aber bei mir wirft er jetzt 3 Fehler aus!


symbol  : method getKey()
location: class java.lang.Object
			if((KeyValuePair) it.next().getKey().equals(key)){
                                                 ^

found   : KeyValuePair
required: boolean
			if((KeyValuePair) it.next().getKey().equals(key)){
                           ^

symbol  : variable key
location: class Map
		return key;
                       ^



```
public class Map{


	LinkedList list=new LinkedList();


	int nElems;

	public Map(){
		Map map=new Map();
		nElems=0;
	}


	public boolean add(Object key,Object value){
		if(contains(key)){
			return true;
		}
		else{
			return list.add(new KeyValuePair(key,value));
		}


	}

	public boolean contains(Object key){
		Iterator it=list.iterator();
		while(it.hasNext()){
			if((KeyValuePair) it.next().getKey().equals(key)){
				return true;
			}
			return false;
		}
	}



	public void delete(Object key){
		if(contains(key)){
			key=null;
		}
	}




	public Object getKey(){
		return key;
	}

}
```


warum will er die Methode getKey() nicht? muss ich da was übergeben? das key kennt er nicht(was eigentlich logisch ist, weil ich ja in der Klasse Map nirgends die Variable key deklariert hab..aber .. :autsch: 
delete stimmt wahrscheinlich nicht oder?


----------



## Wildcard (9. Mrz 2005)

```
public Map(){ 
      Map map=new Map(); 
      nElems=0; 
   }
```
Was soll denn das? Mach das weg   


```
public boolean add(Object key,Object value){ 
      if(contains(key)){ 
         return true; 
      } 
      else{ 
         return list.add(new KeyValuePair(key,value)); 
      }
```
Er muss false liefern wenn der Key schon vorhanden ist.


```
public boolean contains(Object key){ 
      Iterator it=list.iterator(); 
      while(it.hasNext()){ 
         if((KeyValuePair) it.next().getKey().equals(key)){ 
            return true; 
         } 
         return false; 
      } 
   }
```

Du hast glaub ich ne Klammer vergessen.


```
public void delete(Object key){ 
      if(contains(key)){ 
         key=null; 
      } 
   } 




   public Object getKey(){ 
      return key; 
   }
```

Das funktioniert nicht. Du musst die Einträge aus der liste löschen!

Falls du 2 LinkedLists verwenden darfst find ich die version schöner, und der Rest der Aufgabe wird dir damit leichter fallen:


```
public class Map2
{
    private LinkedList keys = new LinkedList();
    private LinkedList values = new LinkedList();
    
    public boolean put(Object key,Object value)
    {
        if (contains(key))
            return false;
        return (keys.add(key) & values.add(value));
             
    }
    
    public Object getValue(Object key)
    {
        int i=0;
        Iterator it = keys.iterator();
        while (it.hasNext())
        {
            if (it.next().equals(key))
                return values.get(i);
            i++;
        }
        return null;
    }
    
    public boolean contains(Object key)
    {
        Iterator it = keys.iterator();
        while(it.hasNext())
        {
            if (it.next().equals(key))
                return true;
        }
        return false;
    }
}
```


----------



## mic_checker (9. Mrz 2005)

> ```
> public Map(){
> Map map=new Map();
> nElems=0;
> ...



Das nenn ich mal ne schöne Endlosschleife 



> ```
> if((KeyValuePair) it.next().getKey().equals(key))
> ```



Siehe Wildcards Antwort von oben:

```
if (((KeyValue)it.next()).getKey().equals(key))
```

Wildcard: Das meintest du doch mit Klammer vergessen oder?

Btw. für welches Semester ist das? Hab glaub ich eben was von 2. gelesen (richtig ?) .. Frag nur "einfach so".


----------



## Sindbad1983 (9. Mrz 2005)

maa,du nimmst dir so viel Zeit für mich!
danke!
boa..das ist genial..
aber weißt du, warum bei mir das getKey() nicht funktioniert?
(wenn ich jetzt angenommen nur 1 LinkedList verwende?

Klammer hab ich glaub ich keine vergessen..das getKey() stimmt nicht!

das versteh ich nicht, denn der Iterator geht durch, Paar für Paar..

z.B. "A"  
      "a"  stehen bereits in der Liste

jetzt möcht ich "B" "b" hinzufügen:
dann geht er zum ersten Paar in der Liste ..also "A" "a" ..und schaut ob da B drinnen steht! -> 
getKey().equals(key))

also er nimmt den Key vom ersten Paar heraus("A") und vergleicht ihn mit dem neuen("B")! oder täusch ich mich?
das heißt, ich muss nur "return key" sagen oder?->er soll "A" zurückgeben!-> weil ich ja eh bei dem jeweiligen KeyValuePaar in der Liste bin! das heißt er vergleicht "A" und den neuen Key "B" oder?
Mensch, ich glaub, ich seh das alles zuu kompliziert!   :autsch:


----------



## Wildcard (9. Mrz 2005)

mic_checker hat gesagt.:
			
		

> Wildcard: Das meintest du doch mit Klammer vergessen oder?


jop, das mein ich!
BTW:

```
return (keys.add(key) & values.add(value));
```
In dieser Zeile ist es wichtig wirklich nur ein '&' zu verwenden und nicht wie üblich '&&'.
Wenn du das änderst funktioniert gar nichts mehr


----------



## Wildcard (9. Mrz 2005)

Sindbad1983 hat gesagt.:
			
		

> aber weißt du, warum bei mir das getKey() nicht funktioniert?




```
public Object getKey(){ 
      return key; 
   }
```
Das kann nicht funktionieren weil an dieser Stelle gar kein Key bekannt ist. Ich versteh auch nicht was du da eigentlich machen willst  ???:L


----------



## Sindbad1983 (9. Mrz 2005)

ja stimmt..Klammer vergessen! :-(

jetzt funktioniert getKey auch! 

Ja. 2.Sem Wirtschaftsinformatik!
Ich bin schon im 4.!
Hab bis jetzt alle Prüfungen leicht geschafft!
Aber beim Programmieren hab ich massive Probleme!Und SWEI ist schon 3 Sem.her!
Es fehlt mir irgendwie die Verständnis!
oder die Übung!
oder beides! :-(
Kann mir das alles so schwer vorstellen, schwer zu erklären...!
Ihr werdet das kinderleicht finden, das ist mir klar!

Aber ich werd nicht aufgeben!
Dank Leute wie euch!
Das motiviert, weil sonst würd ich jetzt noch immer bei den Schnittstellen sitzen und nicht wissen, wies weitergeht!
Danke!

Ich werds nur mit einer LinkedList machen!
Werd mich jetzt über die anderen Methoden stürzen!..und hoffentlich nicht stolpern! ;-)


----------



## Wildcard (9. Mrz 2005)

Sindbad1983 hat gesagt.:
			
		

> Es fehlt mir irgendwie die Verständnis!
> oder die Übung!
> oder beides! :-(
> Kann mir das alles so schwer vorstellen, schwer zu erklären...!
> ...


Wenn man Spass dran hat geht's von ganz alleine.
Wenn's Probleme gibt kannst du dich ja melden. Übrigens:
Bei der contains Methode die du oben gepostet hast, hast du einen Fehler gemacht(kA ob du's schon korrigert hast).
Das return true war in der while-Schleife, muss aber so aussehen:


```
public boolean contains(Object key){ 
        Iterator it=list.iterator(); 
        while(it.hasNext()){ 
           if(((KeyValuePairs) it.next()).getKey().equals(key)){ 
              return true; 
           }     
        } 
        return false;
     }
```


----------



## Sindbad1983 (9. Mrz 2005)

naja..das getKey versteh ich jetzt selber nicht mehr ganz!

aber ich muss es ja implementieren!verstehst du?..nur wie?


```
if(((KeyValuePair) it.next()).getKey().equals(key)){
```

ich brauchs ja da!
ich muss doch auf den aktuellen Key zugreifen oder?
tut mir leid!    das müssen echt saublöde Fragen sein, die ich da stelle..


----------



## Wildcard (9. Mrz 2005)

```
if(((KeyValuePair) it.next()).getKey().equals(key))
```
Ich schreib die Zeile mal aus, dann wirds klarer:


```
KeyValuePair pair = (KeyValuePair)it.next();
Object key2 = pair.getKey();
if (key.equals(key2)
    dosomething();
```
das getKey() ist der Getter von KeyValuePairs.
Besser?


----------



## Sindbad1983 (9. Mrz 2005)

maa,ich bin vielleicht blöd!!!

Das ist ja glasklar!
Ich glaub ich checks! Klar...das sind ja die get-Methoden aus KeyValuePairs!

Jetzt spuckt der Compiler keinen Fehler aus!
Ich glaub bis hierher passts!

Mensch, danke Wildcard!
Danke!


```
public class KeyValuePair{

	private Object key;
	private Object value;

	public KeyValuePair(Object key,Object value){
		this.key=key;
		this.value=value;
	}

	public Object getKey(){
		return key;
	}

	public Object getValue(Object key){
		return value;
	}
}
```


das müsst so passen, denk ich mal...


----------



## Wildcard (9. Mrz 2005)

Passt so weit. Wenn bei doppelten Key's der alte Value überschrieben werden soll(musst du wissen), würd ich aber noch ein setValue() dazumachen.


----------



## Wildcard (9. Mrz 2005)

```
public Object getValue(Object key){ 
      return value; 
   }
```
Doch noch ein kleiner Fehler!    Mach den Paramter weg. den brauchst du nicht!


----------



## Sindbad1983 (9. Mrz 2005)

stimmt..danke..den brauch ich natürlich nicht! nur bei set brauch ich Parameter! 

jetzt möcht ichs aber noch schnell ausprobieren:

fehlen tut noch eine toString-Methode in der Klasse Map (werd ich noch machen)

und in der Klasse TestMap:


```
public class TestMap{

        Map map=new Map();
        map.add("A","a");
        map.add("B","b");
}
```

stimmt das so wahrscheinlich nicht oder?


----------



## Wildcard (9. Mrz 2005)

Doch das stimmt so (bis auf die Tatsache das das in eine Methode muss :wink: ).
Und so musst du sie zurückbekommen:

```
public class TestMap{ 

    public static void main(String args[])
    {    Map map=new Map(); 
        map.add("A","a"); 
        map.add("B","b"); 
        System.out.println(map.get("A"));
    }
}
```


----------



## Wildcard (10. Mrz 2005)

Ich hab mir nochmal Gedanken gemacht über die 'eigene Implementation' von LinkedList. Da verkettete Listen sowieso nur 'PseudoListen' sind, ist das halb so tragisch.
Hab mal schnell ein kleines(noch nicht vollständig getestetes) Exemplar einer doppelt verketteten Liste gemacht.
Wenn du willst kannst du es statt der standart LinkedList verwenden.
Das List-Interface beeinhaltet ziemlich viele Methoden, deshalb ist's etwas länger geworden. Keine Ahnung ob ihr die alle braucht, aber schaden kanns ja nicht   
[edit]das Exception-Handling ist auch noch etwas 'suboptimal'  8)  [/edit]


```
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;


/**
 * TODO short description for MyLinkedList.
 * 


 * Long description for MyLinkedList.
 * 
 * @author Wildcard
 * @version $Revision: $
 */
public class MyLinkedList implements List
{
   private int size=0;
   private LinkedListElement root;
   private LinkedListElement last;
   private MyLinkedList list;
   
   
   public MyLinkedList()
   {
       list = this;
   }
   

/**
 * @see java.util.List#size()
 */
public int size()
{  
    return size;
}

/**
 * @see java.util.List#isEmpty()
 */
public boolean isEmpty()
{
    return (size==0);
}

/**
 * @see java.util.List#contains(java.lang.Object)
 */
public boolean contains(Object o)
{
    boolean flag=false;
    Iterator it = iterator();
    while(it.hasNext())
        if(it.next().equals(o))
            flag=true;
    return flag;
}

/**
 * @see java.util.List#iterator()
 */
public Iterator iterator()
{
    return new Iterator()
    {
        private int count=0;
        private Object[] listElements = list.toArray();
        private int length = list.size;
        
        public boolean hasNext()
        {
            
            if (count<length)
                return true;
            return false;
        }

        public Object next()
        {
            count++;
            return listElements[count-1];
        }

        public void remove()
        {
            count--;
            length--;
            list.remove(count);
        }
    };
}

/**
 * @see java.util.List#toArray()
 */
public Object[] toArray()
{
    return toArray(null);
}

/**
 * @see java.util.List#toArray(java.lang.Object[])
 */
public Object[] toArray(Object[] a)
{
    if (root==null)
        return null;
    if (a==null || a.length<size+1)
        a = new Object[size];
    LinkedListElement listElement=root;
    a[0]=listElement.getElement();
    for (int i=1;i<size;i++)
    {
        listElement=listElement.getChild();
        a[i]=listElement.getElement();
    }    
    return a;
}

/**
 * @see java.util.List#containsAll(java.util.Collection)
 */
public boolean containsAll(Collection c)
{
    Iterator it = c.iterator();
    
    while(it.hasNext())
    {
        boolean flag = false;
        Iterator it2  = iterator();
        while (it2.hasNext())
        {
            if (it.next().equals(it2.next()))
                flag = true;
        }
        if (flag==false)
            return false;
    }
    return true;
}

/**
 * @see java.util.List#addAll(java.util.Collection)
 */
public boolean addAll(Collection c)
{   
    return addAll(size,c);
}

/**
 * @see java.util.List#addAll(int, java.util.Collection)
 */
public boolean addAll(int index, Collection c)
{
    
    Iterator it = c.iterator();
    while(it.hasNext())
    {
        add(index,it.next());
        index++;
    }
    return true;
}

/**
 * @see java.util.List#removeAll(java.util.Collection)
 */
public boolean removeAll(Collection c)
{
    Iterator it = c.iterator();
    boolean flag = false;
    while(it.hasNext())
    {
        if(remove(it.next()))
            flag=true;
    }
    return flag;
}

/**
 * @see java.util.List#retainAll(java.util.Collection)
 */
public boolean retainAll(Collection c)
{
    if(equals(c))
        return false;
    clear();
    addAll(c);
    return true;
}

/**
 * @see java.util.List#clear()
 */
public void clear()
{
    root = null;
    last = null;
    size=0;
    
}

/**
 * @see java.util.List#get(int)
 */
public Object get(int index)
{
    if (index>size)
        throw new ArrayIndexOutOfBoundsException(index);
    LinkedListElement element = root;
    for(int i=1;i<index+1;i++)
        element=element.getChild();
    return element.getElement();
}

/**
 * @see java.util.List#set(int, java.lang.Object)
 */
public Object set(int index, Object element)
{
    Object oldElement = get(index);
    remove(index);
    add(index,element);
    return oldElement;
}

/**
 * @see java.util.List#add(int, java.lang.Object)
 */
public void add(int index, Object element)
{

    if (index>size || index<0)
        throw new ArrayIndexOutOfBoundsException(index);
    if (index==size)
    {
        add(element);
        return;
    }
    else
    {
        LinkedListElement listElement = getListElement(index);
    
        LinkedListElement newElement = new LinkedListElement(element,listElement.getParent());
        if (listElement.getParent()!=null)
            listElement.getParent().append(newElement);
        listElement.setParent(newElement);
        newElement.append(listElement);
        if(index==0)
            root=newElement;
        size++;
    }
    
}
/**
 * Hilfsmethode
 * @param index
 */
private LinkedListElement getListElement(int index)
{
    if (index==0)
        return root;
    LinkedListElement listElement = root;
    for (int i=1;i<index;i++)
    {
        listElement = listElement.getChild();
    }
    return listElement;   
}



/**
 * @see java.util.List#indexOf(java.lang.Object)
 */
public int indexOf(Object o)
{
    Iterator it = iterator();
    int index=-1;
    int counter=0;
    while(it.hasNext())
    {
        if(it.next().equals(o))
            return counter;
        counter++;
    }
    return index;
}

/**
 * @see java.util.List#lastIndexOf(java.lang.Object)
 */
public int lastIndexOf(Object o)
{
    Iterator it = iterator();
    int index=-1;
    int counter=0;
    while(it.hasNext())
    {
        if(it.next().equals(o))
            index=counter;
        counter++;
    }
    return index;
}

/**
 * @see java.util.List#listIterator()
 */
public ListIterator listIterator()
{
    return listIterator(0);
}

/**
 * @see java.util.List#listIterator(int)
 */
public ListIterator listIterator(final int index)
{
    return new ListIterator()
    {
        private int count=index;
        private Object[] listElements = list.toArray();
        private int length = listElements.length;
        
        public boolean hasNext()
        {
            
            if (count<length)
                return true;
            return false;
        }

        public Object next()
        {
            count++;
            return listElements[count-1];
        }

        public boolean hasPrevious()
        {
            
            return (count>0);
        }

        public Object previous()
        {
            count--;
            return listElements[count];
        }

        public int nextIndex()
        {
            
            return count+1;
        }

        public int previousIndex()
        {
            return count-1;
        }

        public void remove()
        {
            list.remove(count);

        }

        public void set(Object o)
        {
           list.set(count,o);

        }

        public void add(Object o)
        {
            list.add(count,o);

        }
    };

}

/**
 * @see java.util.List#subList(int, int)
 */
public List subList(int fromIndex, int toIndex)
{
    if(fromIndex < 0 || toIndex > size || fromIndex >= toIndex)
    {
        throw new ArrayIndexOutOfBoundsException();
    }
    MyLinkedList subList = new MyLinkedList();
    ListIterator it = listIterator(fromIndex);
    for(int i=0;i<fromIndex-toIndex;i++)
        subList.add(it.next());
    return subList;
}

/**
 * @see java.util.List#add(java.lang.Object)
 */
public boolean add(Object o)
{
    if (root==null)
    {
        root = new LinkedListElement(o,null);
        last = root;
    }
    else
    {
        LinkedListElement newElement= new LinkedListElement(o,last);
        last.append(newElement);
        last = newElement;   
        
    }
    size++;
    return true;
}

/**
 * @see java.util.List#remove(java.lang.Object)
 */
public boolean remove(Object o)
{
    int index;
    if (size==0 || (index=indexOf(o))==-1)
        return false;
    remove(index);
    return false;
}

/**
 * @see java.util.List#remove(int)
 */
public Object remove(int index)
{
    LinkedListElement oldElement = getListElement(index);
    if (oldElement!=root)
        oldElement.getParent().append(oldElement.getChild());
    else
    {
        root=root.getChild();
        if (root!=null)
            root.setParent(null);
    }
    size--;
    return oldElement;
}
  
}
```
Dazu noch diese Klasse:


```
/**
 * TODO short description for LinkedListElement.
 * 


 * Long description for LinkedListElement.
 * 
 * @author Wildcard
 * @version $Revision: $
 */
public class LinkedListElement
{
    private LinkedListElement child;
    private LinkedListElement parent;
    private Object element;
    
    public LinkedListElement(Object element, LinkedListElement parent)
    {
        this.element=element;
        this.parent = parent;
    }
    
    public void append(LinkedListElement child)
    {
        this.child=child;
    }
    
    public LinkedListElement getChild()
    {
        return child;
    }
    
    public LinkedListElement getParent()
    {
        return parent;
    }
    
    public void setParent(LinkedListElement parent)
    {
        this.parent = parent;
    }
    
    public Object getElement()
    {
        return element;
    }
    
    public void setElement(Object element)
    {
        this.element = element;
    }

}
```


----------



## Sindbad1983 (13. Mrz 2005)

Oh Mann, du bist ja ein Wahnsinn!....soo viel Code!  :applaus: 
Stark!
Ich hab bei meiner Version ein bissl weiterprogrammiert!
Und es geht zumindest schon ein bissl was!
Hab aber grad bei der Ausgabe der Methode getAllKeys() Probleme!
Kann mir da bitte jemand helfen?

ciao,danke!




```
import java.util.*;

public class Map{


	LinkedList list=new LinkedList();


	public void add(Object key,Object value){  //fügt ein KeyValue_Paar hinzu


		KeyValuePair pair=(KeyValuePair)contains(key);

		if(pair!=null){


				pair.setValue(value);

		}
		else{
				list.add(new KeyValuePair(key,value));
		}


	}

	public Object contains(Object key){
	        Iterator it=list.iterator();
	        KeyValuePair test;
	        while(it.hasNext()){
				test=((KeyValuePair) it.next());
	           if(test.getKey().equals(key)){
	              return test;
	           }
	        }
	        return null;
	}


	public Object [] getAllKeys(){ //gibt alle Keys zurück(in einem Array)

		Iterator it3=list.iterator();
		KeyValuePair test;
		int cnt=0;
		Object [] allKeys=new Object[list.size()];

		while(it3.hasNext()){
			test=(KeyValuePair) it3.next();
			allKeys[cnt]=test.getKey();
			cnt++;
		}
		return allKeys;




	}

	public String toString(){

		Iterator it2=list.iterator();
		String s;
		StringBuffer sb=new StringBuffer();
		KeyValuePair test;
		while(it2.hasNext()){
			test=(KeyValuePair) it2.next();
			s= "Key"+test.getKey()+"Value"+test.getValue();
			sb=sb.append(s);

		}
		return sb.toString();

	}
}
```

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


```
public class KeyValuePair{

	private Object key;
	private Object value;

	public KeyValuePair(Object key,Object value){
		this.key=key;
		this.value=value;
	}

	public Object getKey(){
		return key;
	}

	public Object getValue(){
		return value;
	}

	public void setValue(Object value){
		this.value=value;
	}

	public void setKey(Object key){
		this.key=key;
	}
}
```

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


```
public class TestMap{

	public static void main(String[] args){

		Object[] allKeys;

		Map map=new Map();
		map.add("A","a");
		map.add("B","b");
		map.add("C","5");
		System.out.println(map);


		allKeys=map.getAllKeys();


		for(int i=0;i<allKeys.length;i++){
		System.out.println(allKeys.toString());
		}




	}


}
```



Ausgabe: 


KeyA Valuea KeyB Valueb KeyC Value5
[Ljava.lang.Object;@923e30
[Ljava.lang.Object;@923e30
[Ljava.lang.Object;@923e30
Drücken Sie eine beliebige Taste . . .

3 soll halt die 3 Schlüssel zurückgeben!
Weiß aber nicht, wo da der Fehler liegen könnte!?!? :bahnhof: 
Normalerweise dürfte die toString() Methode stimmen!!?


----------



## Beni (13. Mrz 2005)

Du musst auf die einzelnen Elemente des Arrays zugreiffen:

```
for(int i=0;i<allKeys.length;i++){
      System.out.println(allKeys[i].toString());
      }
```
(Mit anderen Worten, du hast das _ vergessen)_


----------



## Sindbad1983 (13. Mrz 2005)

aja..stimmt!
->blöder Fehler!

Danke für die schnelle Hilfe Beni! ;-)
ciao


----------



## Sindbad1983 (13. Mrz 2005)

So ich hab mich mit meinem Beispiel jetzt noch ein wenig gespielt, bzw. modifiziert:

Ich hab die contains-Methode geringfügig verändert, und jetzt funktioniert sie nicht mehr!
Kann mir bitte jemand sagen, warum?
Stimmt der Rückgabewert nicht, oder hab ich was übersehen? :bahnhof: 


```
import java.util.*;


public class Map{

	LinkedList list=new LinkedList();
	KeyValuePair pair;

	public void add(Object key,Object value){

		if(list.contains(key)){
			pair.setValue(value);
		}
		else{
			list.add(new KeyValuePair(key,value));
		}



	}


	public boolean contains(Object key){
		
		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair) it.next();
			if(pair.getKey().equals(key)){
				return true;
			}
		}
		return false;
	}


	public String toString(){

		StringBuffer sb=new StringBuffer();
		KeyValuePair pair;
		String s;

		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair) it.next();
			s=""+pair.getKey()+""+pair.getValue()+" ";
			sb.append(s);
		}

		s=sb.toString();
		return s;
	}
}
```

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

die anderen 2 Klassen bleiben gleich! 


danke,mahlzeit!!


----------



## Wildcard (13. Mrz 2005)

Die Methode ist richtig. Was funktoniert bei dir nicht?


----------



## Sindbad1983 (13. Mrz 2005)

nein..danke Wildcard..hat sich schon erledigt! 


Ich hab heut den ganzen Tag programmiert und  mein Bestes gegeben!
->damit du siehst, dass ich fleißig war und nicht so schnell aufgib!  :wink: 



```
import java.util.*;


public class Map{

	LinkedList list=new LinkedList();


	public void add(Object key,Object value){

		KeyValuePair pair=(KeyValuePair)contains(key);


		if(pair!=null){
			pair.setValue(value);
		}
		else{
			list.add(new KeyValuePair(key,value));
		}
	}

	public void delete(Object key){

		KeyValuePair pair;

		pair=(KeyValuePair)findKeyValue(key);

		list.remove(pair);
	}


	public int giveSize(){
		int cnt=0;

		Iterator it=list.iterator();
		while(it.hasNext()){
			it.next();
			cnt++;
		}
		return cnt;
	}


	public boolean isEmpty(){

		if(list.size()==0) {
			return true;
		}

		return false;

	}


	public Object findKeyValue(Object key){

		KeyValuePair pair;

		Iterator it=list.iterator();
			while(it.hasNext()){
				pair=(KeyValuePair)it.next();

				if(pair.getKey()==key){
					return pair;
				}
			}
			return null;

	}


	public Object contains(Object key){

		KeyValuePair pair;
		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair) it.next();
			if(pair.getKey().equals(key)){
				return pair;
			}
		}
		return null;

	}


	public Object findValue(Object key){

		KeyValuePair pair;

		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair) it.next();

			if(pair.getKey().equals(key)){
				return pair.getValue();
			}

		}
		return null;
	}


	public boolean isValueDefined(Object key){

		KeyValuePair pair;

		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair) it.next();

			if(pair.getKey().equals(key)){
				if(pair.getValue()!=null){
					return true;
				}
			}
		}
		return false;
	}



	public Object [] getAllKeys(){

		Object [] allKeys=new Object[list.size()];
		Iterator it=list.iterator();
		KeyValuePair pair;
		int cnt=0;

		while(it.hasNext()){
			pair=(KeyValuePair) it.next();
			allKeys[cnt]=pair.getKey();
			cnt++;
		}
		return allKeys;
	}


	public Object [] getAllValues(){

		Object [] allValues=new Object[list.size()];
		KeyValuePair pair;
		int cnt=0;

		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair)it.next();

			allValues[cnt]=pair.getValue();
			cnt++;
		}

		return allValues;

	}

	public boolean equals(Map m){
		
		
		
                    //das fehlt noch ->ein Vergleich zweier Maps auf Gleichheit!
		
	}





	public String toString(){

		StringBuffer sb=new StringBuffer();
		KeyValuePair pair;
		String s;

		Iterator it=list.iterator();
		while(it.hasNext()){
			pair=(KeyValuePair) it.next();
			s=""+pair.getKey()+""+pair.getValue()+" ";
			sb.append(s);
		}

		s=sb.toString();
		return s;
	}








}
```

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


Schaut doch nicht schlecht aus oder?
Es funktioniert alles...hast du noch Verbesserungsvorschläge?
 :bae: aber ich bin ehrlich gesagt schon froh, dass es überhaupt was ausgibt!  :lol: 


Hast du eine Idee, wie ich an die Methode equals(Map p) herangehen könnte?
Es ein bissl schwierig, werds aber vielleicht heut nochmal probieren, wenn ich Zeit hab!

Danke für deine bisherige Hilfe!
ciao,Tommy


----------



## Wildcard (13. Mrz 2005)

Sieht doch schon gut aus!  :toll: 
Noch ein paar Anmerkungen:

```
public int giveSize(){ 
      int cnt=0; 

      Iterator it=list.iterator(); 
      while(it.hasNext()){ 
         it.next(); 
         cnt++; 
      } 
      return cnt; 
   }
```
brauchst du gar nicht so komliziert zu machen! Einfach list.size() zurückgeben  :wink: 


```
public Object findKeyValue(Object key){ 

      KeyValuePair pair; 

      Iterator it=list.iterator(); 
         while(it.hasNext()){ 
            pair=(KeyValuePair)it.next(); 

            if(pair.getKey()==key){ 
               return pair; 
            } 
         } 
         return null; 

   }
```
Mach diese Methode besser private. Es ist eine interne Hilfsmethode und geht niemanden etwas an.
Auserdem gibst du ein KeyValuePair zurück, deklarierst es aber als Object. Gib lieber gleich ein KeyValuePair zurück, dann sparst du dir auch den späteren cast!

Ansonsten würd ich vorschlagen das du die Methodennamen besser an die vorgaben des List Interfaces anpasst.
Schau dir einfach mal an wie die entsprechenden Methoden in einer echten Hashmap heißen, und benenn deine genauso. Ist aber nur Kosmetik.



			
				Sindbad1983 hat gesagt.:
			
		

> Hast du eine Idee, wie ich an die Methode equals(Map p) herangehen könnte?


Ist nicht sonderlich kompliziert:
Als erstes prüfst du ob die Länge gleich ist. Wenn nicht direkt false zurückgeben.
Wenn die länge gleich ist prüfst du ob alle Key's identisch sind(und deren entsprechende Values) und wenn nicht false zurückliefern.


----------



## mic_checker (13. Mrz 2005)

Denk auch dran das gewisse Anforderungen an die equals Methode gestellt werden (die oft allerdings nicht beachtet werden).

Hier mal ein Ausschnitt aus Core Java 2 , Volume I :



> 1) It is reflexive: for any non-null reference x, x.equals(x) should return true.
> 
> 2) It is symmetric: for any references x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
> 
> ...



Du bist natürlich nicht gezwungen es so zu programmieren, dass deine equals Methode tatsächlich alle Punkte erfüllt (und eine Äquivalenzrelation bildet) , allerdings schadet es auch nicht 


```
public boolean equals(Object otherObject)
{
...
}
```
 

Was da oben steht hört sich vielleicht auf den ersten Blick etwas kompliziert an, aber was letztendlich dahinter steht ist recht einfach:
- wenn "null" übergeben wird muss die Methode false zurückgeben
- wenn this == otherObject dann true
- etc. pp.

Ist nur als kleiner Hinweis gedacht, lass dich dadurch nicht verwirren.


----------



## Wildcard (13. Mrz 2005)

Ganz einfache Methode die diese Bedingungen erfüllt:

```
public boolean equals(Object otherObject) 
{ 
    return otherObject.equals(this);
}
```
 :bae:


----------



## Sindbad1983 (13. Mrz 2005)

danke!
ich kann das Beispiel leider erst am Mi fertig machen!
Ich muss schon mit dem nächsten anfangen!
Vielleicht könnt ihr mit bei dem wieder ein bisschen unter die Arme greifen! Ich werd dann gleich ein paar Fragen online stellen!
ciao,Tommy


----------

