Form ändern

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Da du keine weiteren Angaben machst, weshalb du das umgeformt haben willst, geh ich einfach mal davon aus das dir der Code zu einfach ist. Kein Problem hier bekommst du ne Lösung mit so vielen Pattern wie möglich.

    Zuersteinmal brauchen wir einen Automat der bestimmt wann das gelesene zu Ende ist. Um den Automat definieren zu können brauchen wir erst einmal ein Interface für die Übergänge:

    Quellcode

    1. package butalive;
    3. public interface Transaction {
    5. public void readSeparator(Automat a);
    6. public void readChar(Automat a);
    7. }


    Als nächstes brauchen wir Zustände dabei implementieren wir die Übergänge von einem Zustand zum anderen

    Quellcode

    1. package butalive;
    3. public enum State implements Transaction{
    4. A
    5. {
    6. @Override
    7. public void readChar(Automat a) {
    8. a.setState(this);
    9. }
    11. @Override
    12. public void readSeparator(Automat a) {
    13. a.setState(B);
    14. }
    16. @Override
    17. public boolean isFinal()
    18. {
    19. return false;
    20. }
    22. },
    24. B
    25. {
    26. @Override
    27. public void readChar(Automat a) {
    28. throw new RuntimeException("Final State erreicht");
    29. }
    31. @Override
    32. public void readSeparator(Automat a) {
    33. throw new RuntimeException("Final State erreicht");
    34. }
    36. @Override
    37. public boolean isFinal() {
    38. return true;
    39. }
    40. };
    42. public abstract boolean isFinal();
    43. }
    Alles anzeigen


    Danach folgt der eigentliche Automat der die Zustände auswertet und zusammenhält:

    Quellcode

    1. package butalive;
    3. public class Automat {
    4. private State state = State.A;
    7. public void setState(State state) {
    8. this.state = state;
    9. }
    11. public void readChar()
    12. {
    13. state.readChar(this);
    14. }
    16. public void readSeparator()
    17. {
    18. state.readSeparator(this);
    19. }
    21. public boolean isFinal()
    22. {
    23. return state.isFinal();
    24. }
    25. }
    Alles anzeigen


    Bevor wir uns an den Parser machen können, brauchen wir etwas das definiert welcher Buchstabe als Trennzeichen definiert wird. Um so generisch wie möglich zu bleiben versteck ich das natürlich hinter einem Interface

    Quellcode

    1. package butalive;
    3. public interface ISeparator {
    4. public boolean isSeparator(char c);
    5. }


    Und hier die Implementierung für Whitespaces als Trenner

    Quellcode

    1. package butalive;
    3. public class WhitespaceSeparator
    4. implements ISeparator
    5. {
    6. @Override
    7. public boolean isSeparator(char c) {
    8. return Character.isWhitespace(c);
    9. }
    10. }


    So nun können wir uns an den Parser machen:

    Quellcode

    1. package butalive;
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.InputStreamReader;
    6. import java.io.Reader;
    8. public class Parser {
    9. private Reader reader;
    10. private ISeparator separtor;
    12. public Parser(InputStream in, ISeparator separator)
    13. {
    14. reader = new InputStreamReader(in);
    15. this.separtor = separator;
    16. }
    18. public String parse() throws IOException
    19. {
    20. Automat a = new Automat();
    21. int read = -1;
    22. StringBuilder builder = new StringBuilder();
    23. while((read = reader.read())>=0 && !a.isFinal())
    24. {
    25. if(separtor.isSeparator((char)read))
    26. {
    27. a.readSeparator();
    28. }
    30. else
    31. {
    32. a.readChar();
    33. builder.append((char)read);
    34. }
    35. }
    37. return builder.toString();
    38. }
    39. }
    Alles anzeigen


    Ich könnte natürlich noch weiter mit Pattern um mich werfen, aber ganz abschrecken vom Programmieren will ich dich natürlich auch nicht. Mit diesem Code als Basis sieht dein Code nun so aus:

    Quellcode

    1. System.out.println(text);
    2. Parser p = new Parser(System.in, new WhitespaceSeparator());
    3. return p.parse();


    Wenn du deine Frage ein bisschen präziser stellst kann ich dir sicher noch besser helfen.

    mfg
    ButAlive