# Zeichenketten in angepasster Form ausgeben



## Terence86 (26. Nov 2016)

Hallo, habe laut PreTest 2 Fehler die ich noch beseitigen muss, nach Stunde ausprobieren und Überlegungen habe ich mich entschlossen das mal zu posten.
Aufgabenstellung:
	

	
	
		
		

		
			








Hinweis was ich auch nicht drin habe im Code: Am letzten  " } " ist noch ein Zeilenumbruch.
Folgende Fehler im Pretest:

```
FEHLER: zuletzt erwarteter und tatsächlich erhaltener Wert unterscheiden sich
erwartet wurde: "public class NochEinHai {
public static void main(String[] args) {
  System.out.println("Hohe Flosse!");
  System.out.println("Hohe Flosse!");
}
}
"
erhalten wurde: "public class NochEinHai {
public static void main(String[] args) {
System.out.println("Hohe   Flosse!");
System.out.println("Hohe   Flosse!");
}
}"

FEHLER: zuletzt erwarteter und tatsächlich erhaltener Wert unterscheiden sich
erwartet wurde: "public class Hi {
  public static void main(String[] args) {
    System.out.println("Hi!");
  }
}
"
erhalten wurde: "public class Hi {
  public static void main(String[] args) {
    System.out.println("Hi!");
  }
}"
```

Mein Code soweit:

```
public static void prettifyJava(int tab) {

        String einruecken = "";

        for (int leerzeichen = 1; leerzeichen <= tab; leerzeichen++) {
            einruecken = einruecken + "+";
        }

        Scanner sc = new Scanner(System.in);

        int block = 0;

        String vor = "";
        String eingabe;
        while (sc.hasNext()) {

            eingabe = sc.next();

            if (eingabe.endsWith(";")) {
                if (block != 0) {
                    for (int i = 1; i <= block; i++) {
                        System.out.print(einruecken);
                    }
                }
                System.out.println(eingabe);
            }

            else if (eingabe.equals("{")) {

                System.out.println(eingabe);
                if (block == 0) {
                    System.out.print(einruecken);
                }
                block++;
            }

            else if (eingabe.equals("}")) {
                block--;

                if (!vor.endsWith(";")) {
                    System.out.println();
                }

                if (block != 0) {
                    for (int i = 1; i <= block; i++) {
                        System.out.print(einruecken);
                    }
                }
              
                System.out.print(eingabe);
            } else

                System.out.print(eingabe + " ");

            vor = eingabe;
        }
      
        sc.close();
    }
```

Tut mir Leid das der Post so lang geworden ist wollte aber keine Frage zur Aufgabenstellung offen lassen.
Für das Beispiel :
public class Hi { public static void main(String[] args) { System.out.println("Hi!"); } }
Bekomme ich das richtige bis auf den letzten Zeilenumbruch am Ende.


----------



## Meniskusschaden (26. Nov 2016)

Es gibt mehrere Probleme. Zum Beispiel versuchst du die Einrückung für die aktuelle Zeile auszugeben, sobald du ein Semikolon findest. Das ist zu spät, denn zu diesem Zeitpunkt können ja schon Teile der Zeile ausgegeben worden sein. Ein anderes Problem ist, dass du die eingelesenen Token jeweils als Ganzes behandelst. Damit würdest du beispielsweise `}}` oder `public class Hi{`nicht korrekt verarbeiten.

Die Schwierigkeit der Aufgabe liegt meines Erachtens darin, dass sich die Zeitpunkte unterscheiden, zu denen du gewisse Informationen hast. So weißt du beispielsweise, dass beim Auftreten der Zeichen `;{}`eine Zeilenschaltung erforderlich ist, du weißt aber noch nicht, wie tief die nächste Zeile eingerückt werden soll denn das hängt ja auch vom nächsten Zeichen ab, das ja ein } sein könnte, welches die Einrücktiefe vermindert.

Ich würde die Zeichen eines Tokens einzeln verarbeiten. Außerdem würde ich die Logik dahingehend ändern, dass ich mir beim Auftreten eines der Zeichen `;{}` in einer boolschen Variable merke, dass eine Zeilenschaltung erforderlich ist. Bei { und } würde ich nur die Blocktiefe anpassen. Das Ausgeben des aktuellen Zeichens würde ich nur an einer Stelle des Codes vornehmen und dort anhand der Variablen prüfen, ob vorher eine Zeilenschaltung erforderlich ist. Zu dem Zeitpunkt ist dann auch die Blocktiefe bekannt, so dass man entsprechend einrücken und den Zeilenschaltungsmerker zurück setzen kann. Bei einem neuen Token muß man dann ggf. nur noch ein Leerzeichen ausgeben.


----------



## mariane (26. Nov 2016)

Ich würde auch mal auf reguläre Ausdrücke und auf die formatierter Ausgabe schauen.


----------



## Terence86 (26. Nov 2016)

Meniskusschaden hat gesagt.:


> Ich würde die Zeichen eines Tokens einzeln verarbeiten.


Meinen sie damit Zeichen für Zeichen Bsp: Baum -> 'B' + 'a' + 'u' + 'm' 
Bei dem Fehler noch ein Hai : Habe ich bei ";" Zuviel Leerzeichen weil er die ganze Zeile bis dahin ausgibt. Wie beseitige ich das?


----------



## Terence86 (26. Nov 2016)

Also ne Erklärung was für ganze Token gemeint ist und einzelne, ggf. an beispiel.


----------



## Meniskusschaden (26. Nov 2016)

Terence86 hat gesagt.:


> Meinen sie damit Zeichen für Zeichen Bsp: Baum -> 'B' + 'a' + 'u' + 'm'


Ja. Falls die vereinfachende Annahme erlaubt ist, dass jede geschweifte Klammern immer durch whitespaces von anderen Zeichen getrennt ist, kannst du das ignorieren. In der Aufgabenstellung habe ich von so einer Vereinfachung aber nichts gesehen. Du kannst dieses bei dir scheinbar gut funktionierende Beispiel:


Terence86 hat gesagt.:


> Für das Beispiel :
> public class Hi { public static void main(String[] args) { System.out.println("Hi!"); } }
> Bekomme ich das richtige bis auf den letzten Zeilenumbruch am Ende.


ja mal so abändern:

```
public class Hi{ public static void main(String[] args) { System.out.println("Hi!"); } }
```
Dann siehst du, dass man eigentlich einzelne Zeichen betrachten muß.


Terence86 hat gesagt.:


> Bei dem Fehler noch ein Hai : Habe ich bei ";" Zuviel Leerzeichen weil er die ganze Zeile bis dahin ausgibt. Wie beseitige ich das?


Ich glaube, dein Code ist noch nicht angemessen organisiert, um das in den Griff zu bekommen. Ich glaube, dazu mußt du es ähnlich machen, wie in Posting #2 oder den Hinweisen der Aufgabenstellung beschrieben.


Terence86 hat gesagt.:


> Also ne Erklärung was für ganze Token gemeint ist und einzelne, ggf. an beispiel.


Ein Token ist das, was dir `sc.next()`zurück liefert, also quasi ein Wort. Der Text `System.out.println("Hohe Flosse!");`würde dabei beispielsweise in die beiden folgenden Token aufgeteilt werden:

```
System.out.println("Hohe
Flosse!");
```
Aktuell würde dein Programm das erste Token einfach ohne Einrückung und Zeilenschaltung ausgeben. Das zweite Token endet mit einem Semikolon, deshalb würde dein Programm erst die Einrückung und dann das Token mit Zeilenschaltung ausgeben:
	
	
	
	





```
System.out.println("Hohe ++++Flosse!");
```
Mein Lösungsvorschlag aus Posting #2 würde so funktionieren:

```
Wiederhole, solange es weitere Token gibt
  Lies das nächste Token
  Wiederhole für alle Zeichen des Tokens
    Falls Blockende
      reduziere Blocktiefe
    Falls Merker "neue Zeile erforderlich" gesetzt
      setze Merker "neue Zeile erforderlich" zurück
      drucke Zeilenvorschub
      drucke Einrückung
    Drucke Zeichen
    Falls relevantes Zeichen für Zeilenschaltung
      setze Merker für "neue Zeile erforderlich"
    Falls Blockanfang
      erhöhe Blocktiefe
  Falls noch Zeichen folgen und Merker "neue Zeile erforderlich" nicht gesetzt
    drucke Leerzeichen
Falls Merker "neue Zeile erforderlich" gesetzt
  drucke Zeilenschaltung
```


----------



## Terence86 (26. Nov 2016)

Meniskusschaden hat gesagt.:


> Wiederhole für alle Zeichen des Tokens


Wie würde die Bedingung das aussehen ?
s.charAt(index) gibt mit die Zeichen an der Stelle wieder. Erster ist 0 aber letzter ist ja unbekannt, da ich nicht weiß aus wie vielen Zeichen sich das Wort (der Token) bildet was eingeben wurde.
OK mit
substring(string.length()-1) .


----------



## Meniskusschaden (26. Nov 2016)

Du kannst dir die Länge mit `s.length()`ausgeben lassen oder alternativ ein Character-Array erzeugen lassen:

```
for (char c : s.toCharArray()) {
    System.out.println(c);
}
```


----------



## Terence86 (26. Nov 2016)

ja arrays hatten wir ja  noch nicht.
ich hätte das ganze eh als String[] eingelesen und dann bearbeitet trim etc.


----------



## Terence86 (26. Nov 2016)

Aber gehen wir deinen Ansatz mal durch, bzw. das ist was ich grade machen.


Meniskusschaden hat gesagt.:


> Wiederhole, solange es weitere Token gibt


while (sc.hasNext()) {



Meniskusschaden hat gesagt.:


> Lies das nächste Token


eingabe = sc.next();




Meniskusschaden hat gesagt.:


> Wiederhole für alle Zeichen des Tokens


Habe ich mir sowas vorgestellt : for (int i = 0; i < (eingabe.length() - 1) ; i++ ) {
Aber da müsste ich ja irgendwie jeden char ausgeben, bis ich auf einen von (;,{,}) treffe und dann die Blocktiefe bestimmen und Zeilenumbruch ausgeben.

Update:

```
for (int i = 0; i < (eingabe.length() - 1) ; i++ ){
               
                if (eingabe.charAt(i) == ';'){
                    System.out.println();
                    if (eingabe.charAt(i) == '{'){
                        System.out.println();
                        block++;
                        if (eingabe.charAt(i) == '}'){
                            System.out.println();
                            block--;
                    System.out.print(eingabe.charAt(i));
```


----------



## Meniskusschaden (26. Nov 2016)

Terence86 hat gesagt.:


> Habe ich mir sowas vorgestellt : for (int i = 0; i < (eingabe.length() - 1) ; i++ ) {


Das sieht vernünftig aus (außer dass das letzte Zeichen ausgelassen wird).


Terence86 hat gesagt.:


> Aber da müsste ich ja irgendwie jeden char ausgeben, bis ich auf einen von (;,{,}) treffe und dann die Blocktiefe bestimmen und Zeilenumbruch ausgeben.


Ich würde mir das aktuelle Zeichen in einer Variablen zwischenspeichern. Das liest sich besser, als die häufigen charAt-Zugriffe. Mit dem Zeichen kannst du dann einfach die Folgeschritte machen, also zunächst prüfen, ob es das Block-Ende-Zeichen ist. Das nächste Zeichen verarbeitest du erst in der nächsten Schleifen-Iteration.


----------



## Terence86 (26. Nov 2016)

Hi habs grade erst gelesen aber dennoch der bisherige Code:

```
while (sc.hasNext()) {
            // Liest den ersten Token und gibt zu eingabe
            eingabe = sc.next();
            // Wiederholung für alle Zeichen des Tokens
            for (int i = 0; i < eingabe.length(); i++) {

                zeilenumbruch = false;
                System.out.print(eingabe.charAt(i));
                if (eingabe.charAt(i) == ';') {
                    System.out.println();
                    zeilenumbruch = true;
                   
                }
                if (eingabe.charAt(i) == '{') {
                    block++;
                    System.out.println();
                    zeilenumbruch = true;
                }
                if (eingabe.charAt(i) == '}') {
                    block--;
                    System.out.println();
                    zeilenumbruch = true;
                }

            }

            if (zeilenumbruch) {
                if (block != 0) {
                    for (int i = 1; i <= block; i++) {
                        System.out.print(einruecken);
                    }
                }
                System.out.print("");
            } else {
                System.out.print(" ");
            }
        }

    }
```

Funktioniert soweit bis auf den Einschub der zählt zu spät runter. Hier das Ergebnis vom Beispiel mit + als Leerzeichen.

```
public class Hi { public static void main(String[] args) { System.out.println("Hi!"); } }
public class Hi {
++public static void main(String[] args) {
++++System.out.println("Hi!");
++++}
++}
```


----------



## Terence86 (26. Nov 2016)

Wie löse das am besten? Bei dem Fall ";" einfach block abziehen würde für das Beispiel klappen, aber das macht man ja nicht.  Also müsste ich irgendwie bei dem Fall "}" vorher schon den Blockabziehen, das es stimmt beim einruecken.


----------



## Meniskusschaden (26. Nov 2016)

Terence86 hat gesagt.:


> Also müsste ich irgendwie bei dem Fall "}" vorher schon den Blockabziehen, das es stimmt beim einruecken.


Richtig, du kannst kein Zeichen ausgeben, bevor du weißt, ob es das Block-Ende-Zeichen ist, denn es ist das einzige Zeichen, das die eigene Einrücktiefe beeinflusst. Die anderen Zeichen beeinflussen nur die Einrücktiefe der folgenden Zeichen. Deshalb habe ich in meinem Vorschlag in der Schleife zuerst geprüft, ob es ein Blockende ist.


----------



## Terence86 (26. Nov 2016)

Verstehe ich das richtig, soll ich meine for-schleife nur dazu benutzten ob ein Blockende  { vorkommt , und wenn ja ein block abziehen.
Und die restlichen ifs in der while schleife dann erledigen?


Meniskusschaden hat gesagt.:


> alls Merker "neue Zeile erforderlich" gesetzt


 Eine boolean variable?


----------



## Meniskusschaden (26. Nov 2016)

Terence86 hat gesagt.:


> Verstehe ich das richtig, soll ich meine for-schleife nur dazu benutzten ob ein Blockende { vorkommt , und wenn ja ein block abziehen.


Nein, es ist aber so ziemlich das Erste, das du in der Schleife tun solltest. Dein letztes Beispiel ist schon relativ nah dran. Teilweise muß die Reihenfolge noch geändert werden und noch ein paar Detailkorrekturen.


Terence86 hat gesagt.:


> Eine boolean variable?


Ja.


----------



## Terence86 (26. Nov 2016)

OK noch mal Step by Step vielleicht verstehe ich es dann.


Meniskusschaden hat gesagt.:


> Wiederhole, solange es weitere Token gibt


while (sc.hasNext())


Meniskusschaden hat gesagt.:


> Lies das nächste Token


eingabe = sc.next();


Meniskusschaden hat gesagt.:


> Wiederhole für alle Zeichen des Tokens




```
for (int i = 0; i < eingabe.length(); i++) {
char z = eingabe.charAt(i);
zeilenumbruch = false;
```



Meniskusschaden hat gesagt.:


> Falls Blockende
> reduziere Blocktiefe




```
if (z == '}'){
block--;
}
```



Meniskusschaden hat gesagt.:


> Falls Merker "neue Zeile erforderlich" gesetzt
> setze Merker "neue Zeile erforderlich" zurück
> drucke Zeilenvorschub
> drucke Einrückung
> Drucke Zeichen




```
if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    System.out.print(einruecken); //einruecken sind bei mir die Leerzeichen aus int Tab
                     System.out.print(z);}
```



Meniskusschaden hat gesagt.:


> Falls relevantes Zeichen für Zeilenschaltung
> setze Merker für "neue Zeile erforderlich"




```
if (z == ';' || z=='}' || z=='{'){
                    zeilenumbruch = true;
                }
```



Meniskusschaden hat gesagt.:


> Falls Blockanfang
> erhöhe Blocktiefe




```
if (z == '{') {
                    block++;
                }
```



Meniskusschaden hat gesagt.:


> Falls noch Zeichen folgen und Merker "neue Zeile erforderlich" nicht gesetzt
> drucke Leerzeichen




```
if (!zeilenumbruch) {
                    System.out.print(" ");
                }
```



Meniskusschaden hat gesagt.:


> Falls Merker "neue Zeile erforderlich" gesetzt
> drucke Zeilenschaltung


Zeilenschaltung wieder ein Zeilenumbruch?

Ja so weit in der Überlegung kommt das hin?


----------



## Terence86 (26. Nov 2016)

Meniskusschaden hat gesagt.:


> Nein, es ist aber so ziemlich das Erste, das du in der Schleife tun solltest. Dein letztes Beispiel ist schon relativ nah dran. Teilweise muß die Reihenfolge noch geändert werden und noch ein paar Detailkorrekturen.


Können wir da ansetzten? Das andere "siehe letzter post" bricht in mir ein Krise aus =(..


----------



## Meniskusschaden (26. Nov 2016)

Terence86 hat gesagt.:


> Ja so weit in der Überlegung kommt das hin?


Fast. Folgendes fällt mir noch auf:

Zu Beginn der for-Schleife setzt du den Zeilenschaltungsmerker unbedingt auf false. Das gehört noch vor die while-Schleife. Innerhalb der Schleifen muß ja evtl. noch eine Zeilenschaltung ausgegeben werden, die aus der vorherigen Schleifen-Iteration stammt. Das würdest du so unterdrücken.

Du rückst nur um eine Ebene ein. Du müsstest aber entsprechend der Variablen block einrücken.

Die Ausgabe des Zeichens findet in der Bedingungsabfrage für die Zeilenschaltung statt. So würden ja viele Zeichen fehlen.

Die Ausgabe des Leerzeichens befindet sich noch innerhalb der for-Schleife. Es sollte aber ausserhalb sein, denn ein Leerzeichen ist ja nicht nach jedem Zeichen nötig, sondern nur nach jedem Wort.


----------



## Terence86 (26. Nov 2016)

```
String einruecken = "";

        for (int leerzeichen = 1; leerzeichen <= tab; leerzeichen++) {
            einruecken = einruecken + "+";
        }

        Scanner sc = new Scanner(System.in);

        int block = 0;
        boolean zeilenumbruch = false;
        String eingabe = "";

        while (sc.hasNext()) {
            // Liest den ersten Token und gibt zu eingabe
            eingabe = sc.next();

            // Wiederholung für alle Zeichen des Tokens
            for (int i = 0; i < eingabe.length(); i++) {
                char z = eingabe.charAt(i);

                if (z == '}') {
                    block--;
                    zeilenumbruch = true;
                }

                if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    if (block != 0) {
                        for (int j = 1; j <= block; j++) {
                            System.out.print(einruecken);
                        }
                    }
                    System.out.print(z);
                }

                if (z == ';' || z == '}' || z == '{') {
                    zeilenumbruch = true;
                }

                if (z == '{') {
                    block++;

                }

                if (!zeilenumbruch) {
                    System.out.print(z);
                }

            }

        }

    }
```

So habe den Code komplett gepostet. 
Ausgabe hierzu:

```
public class Hi { public static void main(String[] args) { System.out.println("Hi!"); } }
publicclassHi
++ppublicstaticvoidmain(String[]args)
++++SSystem.out.println("Hi!")
++}
}
```

Die Einrückung durch die Tabs stimmen nun, fehlen tun die leerzeichen einiger andere zeichen doppelte zeichen und der zeilenumbruch am ende.


----------



## Terence86 (26. Nov 2016)

Durch die Umstellung am ende:

```
if (z == '{') {
                    block++;

                }

                //if (!zeilenumbruch) {
                    //System.out.print(z);
                //}

            }
            System.out.print(eingabe + " ");
        }
```
Bekomme ich nun wenigstens sowas:

```
public class Hi { public static void main(String[] args) { System.out.println("Hi!"); } }
public class Hi {
++ppublic static void main(String[] args) {
++++SSystem.out.println("Hi!");
++}}
}}
```

Aber woher kommen die doppelten Anfangszeichen? Sehe ich nicht.


----------



## Terence86 (26. Nov 2016)

```
}
            if (!zeilenumbruch){
            System.out.print(eingabe + " ");}
            else {
                System.out.print(eingabe + "");
            }
```
Habe das wie im vorherigen Code mal so gelöst. Jetzt sind die nervigen Leerzeichen weg, aber immer noch doppelte Zeichen die ich nicht will und der Zeilenumbruch am Ende fehlt.
 Ok fehler 1 gefunden :

```
if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    if (block != 0) {
                        for (int j = 1; j <= block; j++) {
                            System.out.print(einruecken);
                        }
                    }
                    //System.out.print(z);
```
System.out.print(z) war natürlich zuviel.


----------



## Meniskusschaden (26. Nov 2016)

Ich habe deinen Code aus Post #20 (nur die while-Schleife) mal korrigiert und die Änderungen kommentiert. Hatte das vor deinen Posts #21 und #22 schon fertig, deshalb ist das nicht berücksichtigt:

```
while (sc.hasNext()) {
            // Liest den ersten Token und gibt zu eingabe
            eingabe = sc.next();

            // Wiederholung für alle Zeichen des Tokens
            for (int i = 0; i < eingabe.length(); i++) {
                char z = eingabe.charAt(i);

                if (z == '}') {
                    block--;
                    // zeilenumbruch = true; //überflüssig
                }

                if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    // if (block != 0) { // überflüssig
                        for (int j = 1; j <= block; j++) {
                            System.out.print(einruecken);
                        }
                    // } // überflüssig
                    // System.out.print(z); // nicht hier ausgeben ...
                }
                System.out.print(z); // ... sondern hier

                if (z == ';' || z == '}' || z == '{') {
                    zeilenumbruch = true;
                }

                if (z == '{') {
                    block++;

                }

                // if (!zeilenumbruch) {     Nicht hier das Zeichen ausgeben ...
                    // System.out.print(z);
                // }

            }
            if (!zeilenumbruch) { // ... sondern hier das Leerzeichen
                System.out.print(" ");
            }

        }
```



Terence86 hat gesagt.:


> Jetzt sind die nervigen Leerzeichen weg, aber immer noch doppelte Zeichen die ich nicht will und der Zeilenumbruch am Ende fehlt.


Den fehlenden Zeilenumbruch kannst du einfach nach der while-Schleife drucken, sofern die zeilenumbruch-Variable gesetzt ist. Die Ursache für die doppelten Zeichen erklären sich aus der Kommentierung.


----------



## Terence86 (26. Nov 2016)

```
String einruecken = "";

        for (int leerzeichen = 1; leerzeichen <= tab; leerzeichen++) {
            einruecken = einruecken + "+";
        }

        Scanner sc = new Scanner(System.in);

        int block = 0;
        boolean zeilenumbruch = false;
        String eingabe = "";

        while (sc.hasNext()) {
            // Liest den ersten Token und gibt zu eingabe
            eingabe = sc.next();

            // Wiederholung für alle Zeichen des Tokens
            for (int i = 0; i < eingabe.length(); i++) {
                char z = eingabe.charAt(i);

                if (z == '}') {
                    block--;
                    zeilenumbruch = true;
                }

                if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    if (block != 0) {
                        for (int j = 1; j <= block; j++) {
                            System.out.print(einruecken);
                        }
                    }

                }

                if (z == ';' || z == '}' || z == '{') {
                    zeilenumbruch = true;
                }

                if (z == '{') {
                    block++;
                    zeilenumbruch = true;
                }

            }
            if (!zeilenumbruch) {
                System.out.print(eingabe + " ");
            } else {
                System.out.print(eingabe + "");
            }
        } // Hier endet die While-Schleife
        System.out.println("Ja das wars");

    }
```

"Ja das wars" <- mein vermeintlicher Zeilenumbruch gibt er nicht aus


----------



## Meniskusschaden (27. Nov 2016)

Terence86 hat gesagt.:


> "Ja das wars" <- mein vermeintlicher Zeilenumbruch gibt er nicht aus




```
if (zeilenumbruch) {
            System.out.println();
        }
        System.out.println("Ja das wars");
```


----------



## Terence86 (27. Nov 2016)

Mir fällt es echt schwer aber es geht nicht. muss ich den scanner erst closen? verstehe grade nicht das Problem..


----------



## Terence86 (27. Nov 2016)

Meniskusschaden hat gesagt.:


> *if* (zeilenumbruch) {
> System.out.println();
> }
> System.out.println("Ja das wars");


Ich denke mal das sollte hinter die while schleife? Auch wenn ich die Abfrage nicht verstehe warum ich die brauche, macht er es nicht.
Warum kann ich nach der while nichts mehr ausgeben?


----------



## Meniskusschaden (27. Nov 2016)

Terence86 hat gesagt.:


> Ich denke mal das sollte hinter die while schleife?


Ja, genau dahin, wo es vorher auch war. Deshalb habe ich das "ja das wars" als Bezugspunkt stehen lassen.


Terence86 hat gesagt.:


> Auch wenn ich die Abfrage nicht verstehe warum ich die brauche,


Die hat den Sinn, nur dann noch eine Zeilenschaltung auszugeben, wenn es nötig ist.


Terence86 hat gesagt.:


> Warum kann ich nach der while nichts mehr ausgeben?


Das kann ich nicht nachvollziehen. Mit deinem letzten Code wird es bei mir ausgegeben. Allerdings gibst du inzwischen wieder vollständige Token aus, so dass die Ausgabe fehlerhaft sein wird, falls innerhalb eines Tokens eine Zeilenschaltung erforderlich ist.


----------



## Terence86 (27. Nov 2016)

```
public static void prettifyJava(int tab) {
      
        String einruecken = "";
       
     
        for (int leerzeichen = 1; leerzeichen <= tab; leerzeichen++) {
            einruecken = einruecken + " ";
        }
       
        Scanner sc = new Scanner(System.in);

       
        int block = 0;
      
        boolean zeilenumbruch = false;
        String eingabe = "";

        while (sc.hasNext()) {
          
            eingabe = sc.next();

           
            for (int i = 0; i < eingabe.length(); i++) {
                char z = eingabe.charAt(i);

               
               
                if (z == '}') {
                    block--;
                    zeilenumbruch = true;
                }
              
               
                if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    if (block != 0) {
                        for (int j = 1; j <= block; j++) {
                            System.out.print(einruecken);
                        }
                    }

                }
               
               
                if (z == ';' || z == '}' || z == '{') {
                    zeilenumbruch = true;
                }
              
                if (z == '{') {
                    block++;
                    zeilenumbruch = true;
                }

            } <- Hier endet die for-schleife
          
            if (!zeilenumbruch) {
                System.out.print(eingabe + " ");
               
            } else {
                System.out.print(eingabe + "");
            }

        } <-Hier endet die while-Schleife
        sc.close();
        if (zeilenumbruch) {
            System.out.print("test test test kommt nichts");
        }
        System.out.println("Ja das wars ja kommt auch nichts");
    }
```
Nochmal den Code gepostet.


----------



## Terence86 (27. Nov 2016)

Habe 


Terence86 hat gesagt.:


> *if* (!zeilenumbruch) {
> System.out.print(eingabe + " ");
> 
> } *else* {
> ...


noch um geändert und in die for - schleife rein, falls mal echt ein }} kommen sollte. 
Aber der letzten Zeilenumbruch will und will nicht.


----------



## Terence86 (27. Nov 2016)

```
public class Prettifier {
    public static void prettifyJava(int tab) {
        // String der meine Leerzeichen später löst
        String einruecken = "";

        for (int leerzeichen = 1; leerzeichen <= tab; leerzeichen++) {
            einruecken = einruecken + " ";
        }

        Scanner sc = new Scanner(System.in);

        int block = 0;

        boolean zeilenumbruch = false;
        String eingabe = "";

        while (sc.hasNext()) {

            eingabe = sc.next();

            for (int i = 0; i < eingabe.length(); i++) {
                char z = eingabe.charAt(i);

                if (z == '}') {
                    block--;
                    zeilenumbruch = true;
                }

                if (zeilenumbruch) {
                    zeilenumbruch = false;
                    System.out.println();
                    if (block != 0) {
                        for (int j = 1; j <= block; j++) {
                            System.out.print(einruecken);
                        }
                    }

                }

                if (z == ';' || z == '}' || z == '{') {
                    zeilenumbruch = true;
                }

                if (z == '{') {
                    block++;
                    zeilenumbruch = true;
                }
                if (!zeilenumbruch) {
                    System.out.print(z);

                } else {
                    System.out.print(z);

                }
            }
            if (!zeilenumbruch) {
                System.out.print(" ");
            }

        }
        System.out.println();
        sc.close();
    }
```

So hat er angenommen. Auch wenn das mit dem Zeilenumbruch komisch ist.
Kommt der nun? Bei mir in der Console nicht. Oder muss ich EOF befehl machen?
Danke ich schon mal oder wieder recht herzlich!!! Daumen hoch!


----------



## Meniskusschaden (27. Nov 2016)

Terence86 hat gesagt.:


> Kommt der nun? Bei mir in der Console nicht.


Doch, er kommt. Folgender Aufruf:

```
public static void main(String[] args) {
    prettifyJava(2);
    System.out.println("Ende");
}
```
führt bei mir zu folgender Ausgabe:

```
public class Hi {
++public static void main(String[] args) {
++++System.out.println("Hi!");
++}
}
Ende
```


----------



## Terence86 (27. Nov 2016)

Ja das Problem lag in Eclipse in der Ausgabe. Da habe ich nachdem ich Enter gedrückt habe keinen Zeilenumbruch am Ende gehabt, und hatte mich natürlich gewundert.  Aber alles gut nun! Danke nochmal!!!


----------

