Zeichenketten in angepasster Form ausgeben

[Terence86]

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]

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]

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

 

[Terence86]

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]

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

 

[Meniskusschaden]

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:

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ß.

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.

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]

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]

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]

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

 

[Terence86]

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

Wiederhole, solange es weitere Token gibt

while (sc.hasNext()) {

Lies das nächste Token

eingabe = sc.next();

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]

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).

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]

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]

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]

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]

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?

alls Merker "neue Zeile erforderlich" gesetzt

Eine boolean variable?

 

[Meniskusschaden]

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.

Eine boolean variable?

Ja.

 

[Terence86]

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

Wiederhole, solange es weitere Token gibt

while (sc.hasNext())

Lies das nächste Token

eingabe = sc.next();

Wiederhole für alle Zeichen des Tokens

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

Falls Blockende
reduziere Blocktiefe

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

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);}

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

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

Falls Blockanfang
erhöhe Blocktiefe

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

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

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

Falls Merker "neue Zeile erforderlich" gesetzt
drucke Zeilenschaltung

Zeilenschaltung wieder ein Zeilenumbruch?

Ja so weit in der Überlegung kommt das hin?

 

[Terence86]

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]

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]

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]

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]

}
            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]

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(" ");
            }

        }

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]

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]

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

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

 

[Terence86]

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

 

[Terence86]

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]

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.

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.

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]

    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]

Habe

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

} else {
System.out.print(eingabe + "");
}

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]

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]

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]

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!!!