# Leere Anweisung



## hüteüberhüte (18. Jan 2013)

```
public static void putMap(Map<String, Object> map, String s) { // + value parameter
        int idx = 0;
        if (s.matches("^\\d+_\\d+$")) {
            int indexOf_ = s.indexOf('_');
            idx = Integer.parseInt(s.substring(indexOf_ + 1));
            s = s.substring(0, indexOf_);
        }
        String sNew;
        while (map.containsKey(sNew = s + "_" + ++idx));
        map.put(sNew, null);
    }
```

IDE sagt mir Leere Anweisung in Zeile 9!


----------



## bone2 (18. Jan 2013)

```
while (map.containsKey(sNew = s + "_" + ++idx));
```
ist tot/endlos, es passiert nie etwas


----------



## hüteüberhüte (18. Jan 2013)

ich raffs nicht


----------



## bone2 (18. Jan 2013)

probiers mal mit 
	
	
	
	





```
{ }
```

du könntset deinen code auch durch 
	
	
	
	





```
while(true);
```
 ersetzen.


edit: da ist ein 
	
	
	
	





```
;
```
 em ende des 
	
	
	
	





```
while
```


----------



## Stroker89 (18. Jan 2013)

Eine While-Schleife sieht normal so aus:


```
while(Anweisung){
    Tue etwas
}
```

deine sieht aber so aus:


```
while();
```

was gar nichts tut.

Hoffentlich bringt das etwas Licht ins Dunkel 

Grüße


----------



## utnovetur (18. Jan 2013)

Hallo,

die leere while-Schleife ist so gewollt.
Innerhalb des Aufrufs von containsKey steht eine Zuweisung an sNew. 
Offensichtlich soll die Map Schlüssel der Form 123_45 enthalten.
Die Methode generiert einen neuen Schlüssel 123_46 und fügt ihn in die Map ein.

Gruß


----------



## Tomate_Salat (18. Jan 2013)

Nein, denn da hinter dem while ein [c];[/c] steht, ist es eine potentielle Endlosschleife.

Ich zieh es mal auseinander, vllt wird es dann klarer:

```
while (map.containsKey(sNew = s + "_" + ++idx))
    ;
map.put(sNew,null);
```

um es noch weiter zu verdeutlichen:


```
while (map.containsKey(sNew = s + "_" + ++idx))
{
}
map.put(sNew,null);
```

das ist alles das gleiche ;-)

ach und noch so am Rande:
Parameter zu überschreiben ist keine sonderlich gute Idee. Wenn du mit Eclipse arbeitest würde ich dir empfehlen, unter den SaveActions einzustellen, Parameter immer final zu machen.


----------



## hüteüberhüte (18. Jan 2013)

utnovetur hat gesagt.:


> Hallo,
> 
> die leere while-Schleife ist so gewollt.
> Innerhalb des Aufrufs von containsKey steht eine Zuweisung an sNew.
> ...



Danke, utnovetur!

Diese Methode funktioniert ja, aber Ide sagt mir, daß ich das so nicht machen darf und zeigt mir den Fehler!

Ganz schön fies... 

Grüßle

Gesendet mit Tapatalk 2


----------



## xehpuk (18. Jan 2013)

Tomate_Salat hat gesagt.:


> Nein, denn da hinter dem while ein [c];[/c] steht, ist es eine potentielle Endlosschleife.


Och, das passt schon so. Da ist ja die Laufvariable 
	
	
	
	





```
idx
```
 dabei. Es wird nur eine Endlosschleife, wenn die Map 2^32 Einträge enthält, wovon ich nicht ausgehen würde.

[OT]





Tomate_Salat hat gesagt.:


> Wenn du mit Eclipse arbeitest würde ich dir empfehlen, unter den SaveActions einzustellen, Parameter immer final zu machen.


Kann ich nicht empfehlen. Hat mir mehrmals den ganzen Code irreversibel zerschossen.[/OT]



hüteüberhüte hat gesagt.:


> Diese Methode funktioniert ja, aber Ide sagt mir, daß ich das so nicht machen darf und zeigt mir den Fehler!


Du kennst schon den Unterschied zwischen Warnung und Fehler?


----------



## Tomate_Salat (18. Jan 2013)

xehpuk hat gesagt.:


> Och, das passt schon so


sobald der Wert nicht als Key enthalten ist, ist es eine Endlosschleife

[OT]





xehpuk hat gesagt.:


> Kann ich nicht empfehlen. Hat mir mehrmals den ganzen Code irreversibel zerschossen.


Dann hast du schonmal einen Fehler gemacht und auf ein SCM verzichtet.
Ansonsten tut es (bei mir über verschieden Eclipseversionen auf mehreren Computern) genau das was es soll. Wenn du Probleme bekommst, dann weil du finale Parameter versuchst zu überschreiben.[/OT]


----------



## hüteüberhüte (18. Jan 2013)

Hihihihi, ja da hast du auch wieder recht, aber ich hab eine etwas umfangreichere Klasse, mit alten Zeugs, was/womit ich abschließen wollte, was aber noch diese gelben .... Warnungen enthält. vlg

Gesendet mit Tapatalk 2


----------



## Spacerat (18. Jan 2013)

Ob die While-Schleife nun tot ist oder nicht, beim Ausdruck "+ ++idx" gehört "++idx" auf jeden Fall in Klammern (zumindest zeigt Eclipse 'nen Fehler, wenn man den Ausdruck in der Bedingung isoliert).


----------



## Bernd Hohmann (18. Jan 2013)

Tomate_Salat hat gesagt.:


> sobald der Wert nicht als Key enthalten ist, ist es eine Endlosschleife



Hm?

Der Key ist "s_"+(idx+1). Wenn der vorhanden ist, geht es mit (idx+2) weiter solange bis der Key nicht vorhanden ist - dann wird er eingefügt.

Ich sehe da weder eine leere noch eine endlose while-Schleife.

Bernd


----------



## dlohd101 (18. Jan 2013)

Hi,

da die Zeile 9 ganz schön verschachtelt ist, wäre es sinnvoll sie etwas übersichtlicher zu schreiben: 


```
sNew = s + "_" + idx;
while (map.containsKey(sNew)){
sNew = s + "_" + (++idx);
}
```

Meine Vermutung ist, dass der Suchstring falsch zusammen gesetzt wird. 

Es muss evtl. auch die Integer-Variable "idx" nach String konvertiert werden:

[c] sNew = s + "_" + Integer.toString(++idx); [/c]



Gruß dlohd101


----------



## Bernd Hohmann (18. Jan 2013)

dlohd101 hat gesagt.:


> da die Zeile 9 ganz schön verschachtelt ist, wäre es sinnvoll sie etwas übersichtlicher zu schreiben:



Dejure läuft das in dieser Konstellation vermutlich (!) auf das gleiche Ergebnis hinaus ausser dass es (vermutlich) einen überflüssigen Schleifendurchlauf ergibt.

Den "++idx" bedeutet, dass 'idx" _erst_ um 1 erhöht und dann genutzt wird.

Bernd


----------



## dlohd101 (18. Jan 2013)

Stimmt...

Wäre demnach in der Form besser:


```
String sNew = s + "_" + idx;
while (map.containsKey(sNew)){
sNew = s + "_" + (idx++);
}
```



Gruß dlohd101


----------



## faetzminator (19. Jan 2013)

Wenn die IDE ein solches Konstrukt tatsächlich als Error - und nicht etwa als Warning - ausgeben sollte, dann würde ich meine Compilereinstellungen anpassen. Meistens ist so was tatsächlich nicht sehr schön, und mit dem Semikolon wohl ein Schreibfehler. Aber ab und an braucht man das ggf. - wär zumindest bei mir nicht das erste Mal.


----------



## Tomate_Salat (19. Jan 2013)

Bernd Hohmann hat gesagt.:


> Ich sehe da weder eine leere noch eine endlose while-Schleife.



hmm, ja mein Fehler. Hab das [c]++[/c] nicht gesehen, jetzt ergibt der Post von xehpuk natürlich viel mehr Sinn. Ich schiebs mal auf Freitag und das "kurz-vor-feierabend-macht-man-die-dümmsten-fehler"-Phänomen


----------



## hüteüberhüte (19. Jan 2013)

Was heißt denn die Schleife ist tot, und wie soll der Compiler das erkennen, sollte ich irgendwelche Einstellungen verändern oder auf stur schalten? Ich danke euch, für eure hilfe, schon mal...


----------



## Spacerat (19. Jan 2013)

Wenn du nicht auf Warnungen stehst, implementiere es wie's dlohd101 vorgeschlagen hat. Die Schleife ist für den Compiler tot. Er sieht an dieser Stelle nur 'ne While-Schleife mit gültiger Bedingung in der nichts geschieht. Liegt daran, dass der Compiler zu dieser Zeit noch nicht weiss, dass innerhalb der Schleife keine weiteren Anweisungen mehr nötig sind, weil sie bereits zur Bedingung gehören.


----------



## bone2 (20. Jan 2013)

Tomate_Salat hat gesagt.:


> hmm, ja mein Fehler. Hab das [c]++[/c] nicht gesehen, jetzt ergibt der Post von xehpuk natürlich viel mehr Sinn. Ich schiebs mal auf Freitag und das "kurz-vor-feierabend-macht-man-die-dümmsten-fehler"-Phänomen


Jo bei mir das gleiche, habe auch das ++ übersehen.
 Würde das in der tat ähnlich dlohd101's code umsetzen, allerdings ist die zweite lösung falsch, zumindest das ergebnis. das erste idx wird zweimal getestet und am ende ist idx einen wert zu hoch.


----------



## Spacerat (20. Jan 2013)

bone2 hat gesagt.:


> Jo bei mir das gleiche, habe auch das ++ übersehen.
> Würde das in der tat ähnlich dlohd101's code umsetzen, allerdings ist die zweite lösung falsch, zumindest das ergebnis. das erste idx wird zweimal getestet und am ende ist idx einen wert zu hoch.


???:L Ob man's evtl. deswegen alles schlicht in die Bedingung gesetzt hat? Aber BTW.: Es ist (mal wieder) wie bei 'ner for Schleife. Der Schleifenzähler ist hinter der Schleife nicht mehr wichtig. Seine 2. Lösung arbeitet also korrekt.


----------



## bone2 (20. Jan 2013)

Spacerat hat gesagt.:


> ???:L Ob man's evtl. deswegen alles schlicht in die Bedingung gesetzt hat? Aber BTW.: Es ist (mal wieder) wie bei 'ner for Schleife. Der Schleifenzähler ist hinter der Schleife nicht mehr wichtig. Seine 2. Lösung arbeitet also korrekt.



weil es schlechter lesbar ist, ist alles im schleifenkopf?
aber ja, es wird sNew und nicht idx gesucht, hab ich bei dem Codeschnipsel vergessen.


----------



## hüteüberhüte (20. Jan 2013)

OK! Jetzt ist etwas seltsames passiert, IDE zeigt mir manchmal den Fehler/Warnung und manchmal auch nicht! Ich war absolut inaktiv. Geister, es spukt!


----------



## Spacerat (21. Jan 2013)

Ist das ein grössers Projekt? Dann ändere mal bissl Quelltext, speichere und achte unten rechts mal auf den Progress (Building workspace...). Solange dauert's bis Fehler und Warnungen in der IDE korrekt angezeigt werden. Anders lässt sich der Spuck erstmal nicht erklären.


----------

