Hilfe-ein kleines Problem!

[prinzesinnn1]

Hallo Leute,
sitze schon ne ganze Weile an meiner Aufgabe und komme einfach nicht weiter.
Ich muss ein Programm schreiben, welches ein Text einliest und ihn aufgrund von Formatierungszeichen nach bestimmen Bedinungen wieder ausspuckt. Z.b. steht vor einem Wort ein _ wird es klein geschrieben.
Habe schon einen echt guten Ansatz, jedoch komm ich nicht weiter beim Suchen des Zeichens, iwas muss da mit indexoff, aber ich bleib einfach stecken. Vielleicht habt ihr ja nen guten Tipp für mich

import java.util.Scanner;


public class Wordprocessor {
	public static void main(String[] args) {
		Scanner s = new Scanner (System.in) ;
		
		System.out.println ("Bitte geben Sie einen Satz ein") ;
		String str = s.nextLine ();	
		
		for ( String str1 :str.split(" +")) {
			
			int length = str1.length() ;
			char a = str1.charAt(0);
			
			
			if ( a == '_')
				System.out.println (str1.substring(1, -1).toUpperCase());

 

[Writtscher]

Vllt. hilft das:

Main

public class Main {

    public static void main(String[] args) {
        TextReader textReader = new SystemInTextReader();
        String text = textReader.read();
        System.out.println(text);
    }

}

TextReader (Abstrakte Klasse. Um mehrere Implementierungen anzubieten..)

public abstract class TextReader {
    private final TextRuleValidation textRuleValidation = new TextRuleValidation();
    private final TextSplitter textSplitter = TextSplitter.on(" ");
    
    public String read() {
        String text = getText();
        List<String> textParts = textSplitter.split(text);
        StringBuilder stringBuilder = new StringBuilder();
        for (String textPart : textParts) {
            stringBuilder.append(textRuleValidation.validateText(textPart));
            stringBuilder.append(" ");
        }

        return stringBuilder.toString();
    }

    protected abstract String getText();
}

Eine Implementierung für TextReader wäre der SystemInReader

public class SystemInTextReader extends TextReader {

    private final Scanner scanner;

    public SystemInTextReader() {
        this.scanner = new Scanner(System.in);
    }

    @Override
    protected String getText() {
        return scanner.nextLine();
    }
}

Ein TextSplitter der den Text anhand etwas splitted (geht besser

public class TextSplitter {
    private final String character;

    private TextSplitter(String character) {
        this.character = character;
    }

    public static TextSplitter on(String character) {
        return new TextSplitter(character);
    }

    public List<String> split(String text) {
        String[] textInParts = text.split(character);
        List<String> result = new ArrayList<String>();
        for (String textInPart : textInParts) {
            result.add(textInPart.trim());
        }
        return result;
    }
}

Und zum Schluß die Regeln

public interface TextRule {
    boolean ruleApplies(String text);
    String apply(String text);
}

public abstract class CharacterStartingTextRule implements TextRule {

    @Override
    public boolean ruleApplies(String text) {
        return text.startsWith(getCharacter());
    }

    @Override
    public String apply(String text) {
        String appliedText = applyRule(text);
        return appliedText.replace(getCharacter(), "");
    }

    protected abstract String applyRule(String text);

    protected abstract String getCharacter();
}

Zwei Beispiele wären

public class EverythingToLowerCase extends CharacterStartingTextRule {

    @Override
    protected String applyRule(String text) {
        return text.toLowerCase();
    }

    @Override
    protected String getCharacter() {
        return "'";
    }

}

public class EverythingToUpperCase extends CharacterStartingTextRule {

    @Override
    protected String applyRule(String text) {
        return text.toUpperCase();
    }

    @Override
    protected String getCharacter() {
        return "_";
    }

}

Und getestet wird es im TextReader mithilfe der TextRuleValidation

public class TextRuleValidation {

    private List<TextRule> textRules = Arrays.<TextRule>asList(
       new EverythingToLowerCase(), new EverythingToUpperCase()
    );

    public String validateText(String text) {
        for (TextRule textRule : textRules) {
            if (textRule.ruleApplies(text)) {
                return textRule.apply(text);
            }
        }
        return text;
    }
}

Vielleicht bissel overkill aber ich bin kein Freund von "Alles Steht In Der Main".

Edit:
Ein Beispiel:
Eingabe: 'KLEIN _groß
Ausgabe: klein GROSS

Eingabe: Das wird _groß und das muss 'KLEIN!
Ausgabe: Das wird GROSS und das muss klein!

 

[HonniCilest]

@Writtscher
Bitte bedenke, dass prinzesinnn1 eine Übungsaufgabe lösen soll. Daher wäre eine solche Lösung sicher nicht im zeitlichen Rahmen. Außerdem dürfen in den meisten Fällen nur stylistische Mittel verwendet werden, welche bereits behandelt wurden. Hier geht es um Strings und Chars welche i.d.R. früh behandelt werden, daher denke ich nicht, dass prinzesinnn1 schon viel mit Interfaces anfangen kann. Zudem wollen wir hier eigentlich keine Lösungen präsentieren sondern bei der Lösungsfindung lediglich Hilfestellung leisten. Desweiteren bitte Java-Code bitte immer in entsprechende Java-Tags verfassen....

@prinzesinnn1
Oft führen viele Wege nach Rom. Jedoch können wir mit einer Aussage wie "irgendetwas mit indexof" erstrecht nicht viel anfangen. Ich finde deine Lösung sieht auf den ersten Blick gut aus. Ist es Pflicht indexof zu verwenden?

 

[prinzesinnn1]

Danke für die Antworten
HonniCilest hat's gut erkannt, bin noch in der Anfangsphase. Wenn man Lösungen bekommt, versteht man gar nix und deswegen halt ich nicht so viel von Trotzdem vielen Danke für die mühe !
Nur muss es ja auch verstehen.
Habe mich damit weiterhin fleißig befasst und einen anderen Lösungsweg gefunden

import java.util.Scanner;

public class Wordprocessor {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in); //

		System.out.println("Bitte geben Sie einen Satz ein"); // Satz eingeben
		String str = s.nextLine(); //In nächster Zeile ausgeben
		if (!str.equals("")){  //Wenn die Eingabe nicht leer ist, dann weiter (in diesem Fall) mit der for-Schleife
							// ansonsten weiter mit else unten
			
		for (String str1 : str.split(" +")) { // for-Schleife ausführen, Satz splitten

			int length = str1.length(); // Bestimmt die Länge der einzelen Wörter

			char a = str1.charAt(0); // Umfasst die Position Null des Wortes
			char b = str1.charAt(length - 1);// Umfasst die letzte Position des Wortes
												
			String substr = ""; //String definiert für Ausgabe später
			

			if (a != '_') {  //Wenn a nicht nicht der Fall ist, dann 
				substr = str1; //Gebe das Wort so aus, wie es eingetippt wurde

			}

			if (a == '_') { // Wenn an Stelle 0 das Zeichen '_' steht, dann führe folgendes aus
				substr = str1.substring(1, length); // Makiert die restlichen Zeichen des Wortes
				substr = substr.toUpperCase(); // Wort wird GROSS geschrieben
			}
			
			if (b == '_') { // Wenn an der letzten Stelle des Wortes '_' steht,dann führe folgendes aus
				substr = substr.substring(0, length - 1); // Makierung der übrigen Zeichen
				substr = substr.toLowerCase(); // Wort wird klein geschrieben
			}

			if (a=='_' && b == '_') {  //Wenn a und b gleichzeitig zutreffen (gilt das letzte Formatierungszeichen)
				substr = substr.substring(0, length - 2); //Makierung der übrigen Zeichen
				substr = substr.toLowerCase(); //Wort wird dann klein geschrieben
			}
			
			
			System.out.print(substr + " "); // Gebe mir das Ergebnis aus + mit Leerzeichen

		}
		} else { //Folgefunktion von equals 
			System.out.println ("Sie haben nichts eingegeben"); //System gibt aus
		
		}
	}

}

 

[Writtscher]

Sorry. Ich hatte Langeweile und bin übers Ziel geschossen .

Zu deinem Code:

if (!str.equals("")){ ...

Ist besser wenn

if (!str.isEmpty()){ ...

Aber sieht ganz gut aus. Funktioniert es denn nun wie es soll?