# Zeichenketten und Satzzeichen



## outbleeder (13. Okt 2012)

Hallo,

ich soll einen eingegeben Text auf auf Groß- und Kleinschreibung prüfen.
Bsp:

der Wald ist schön.Die enge ist gelb! Die häuser auch.

Hier soll nur darauf geachtet werden, dass am Satzanfang alles großgeschrieben 
werden soll. Auch nach einem Satzzeichen. Dies könnte ich mit Upper/Lowercase realisieren.

Jedoch meine Frage ist wie kann ich in der Zeichenkette dies realisieren?
Habe dazu immer einen Substring gebildet und immer weiter gemacht.
Aber ich bekomme es nicht hin.

Könnte man das auch anderes lösen?
Verzweifle hier etwas ...

Bin wirklich dankbar für jeder Hilfe!
:bahnhof:


```
public final class Code {

	/**
	 * @param args
	 */
	
	//Wie viele Satzzeichen habe ich?
	public static int zeichenZähler(String Zeichenkette)
	{	
		int counter =0;
		char[] Satzzeichen = {'?','!',';','.'};
		for (int j = 0; j < Satzzeichen.length; j++) 
		{
			
			for (int i=0;i<Zeichenkette.length();i++)
			{
				if (Zeichenkette.charAt(i) == Satzzeichen[j]) 
					{
						counter++;
					}
			}
		}
		

	return counter;
	}
	
	public static void subLetter(String letter)
	{
		String [] zeichen = {"?","!",";","."};
		
		int anzahl = zeichenZähler(letter);
		String[] sub = new String[anzahl*2];
		
		for (int j = 0; j < anzahl; j++) 
		{
			for (int s = 0; s < zeichen.length; s++) 
			{
				 sub[s] = letter.substring(0,(letter.indexOf(zeichen[j]))+1); //linke Seite des Textes 
				 sub[s+1] = letter.substring((letter.indexOf(zeichen[j]))+1); //rechte Seite
			}
			
		}
		
		for (int i = 0; i < sub.length; i++) 
		{
			System.out.println(sub[i]);
		}
		
		
	}
	
	
	public static void main(String[] args) {
	
		
		String zeichen = "Das Haus ist grün! und du? auch.";
		System.out.println(zeichenZähler(zeichen));
		subLetter(zeichen);


	}

}
```


----------



## Firephoenix (13. Okt 2012)

Wie würdest du es denn per Hand lösen?

Ich würde links anfangen, der 1. Buchstabe muss groß sein. Dann würde ich ein Zeichen nach dem anderen durchgehen, egal ob groß oder klein, solange bis ein "." oder ein "!" kommt. (evtl noch ";" oder ":" abhängig von der Aufgabenstellung).
Nach jedem Satzeichen muss der nächste Buchstabe wieder groß geschrieben sein.


Möglich wäre z.b. so eine Struktur (dort erhälst du aber nur einen boolean, falls du die konkrete stelle ausgeben willst die den Fehler verursacht müsstest du die Methode entsprechend ändern):

```
public static void main(String[] args) {
		String phrase = "der Wald ist schön.Die enge ist gelb! Die häuser auch.";
		System.out.println(checkForUppercases(phrase));
	}

	private static boolean checkForUppercases(String phrase) {
		boolean expectUppercase = true; //der erste char muss groß geschrieben werden
		for(int i = 0; i < phrase.length(); i++){
			char actualChar = phrase.charAt(i);
			if(isPunctuationMark(actualChar)){
				//nach einem satzzeichen wird groß geschrieben
				expectUppercase = true;
			}else if(expectUppercase){
				//lowercase an einer stelle wo uppercase erwartet wird ist ein fehler
				if(isLowercase(actualChar)){
					return false;
				}
				//dann kann bis zum nächsten satzzeichen beliebig geschrieben werden
				expectUppercase = false;
			}
		}
		//läuft der komplette String durch wird true zurückgegeben
		return true;
	}

	private static boolean isLowercase(char actualChar) {
		//TODO ist der char lowercase?
	}

	private static boolean isPunctuationMark(char actualChar) {
		//TODO ist der char ein satzzeichen nach dem groß geschrieben werden muss?
	}
```

Gruß


----------



## outbleeder (14. Okt 2012)

Hallo,

vielen dank für die Idee! Hat mir sehr weitergeholfen !
Nur hab ich noch ein Problem. 
Wenn ich in meinem Satz das Satzzeichen gefunden habe, wie kann ich dann den nächsten Buchstaben ausfindig machen?

Habe die Idee mit isLetter(char ch) //von java.lang.character.
Aber ich weiß doch gar nicht ob nach dem Satzzeichen ein Leerzeichen kommt. Das muss ich ja noch berücksichtigen?


```
public final class Code {


public static boolean isPunctionMark(char punction)
	{
		char[] Satzzeichen = {'?','!',';','.'};
		
		for (int i = 0; i < Satzzeichen.length; i++)
		{
			if(punction == Satzzeichen[i])
			{
				
				return true;
			}

		}
		return false;
		
	}


public static void main(String[] args) {
	
		String Zeichenkette = "das Haus ist grün! und du? auch.";
		String tmp_aktuellZeichenString;
		String tmp_Zeichenkette = Zeichenkette.trim();
		String sub_ZeichenketteLeft;
		String sub_ZeichenketteRight;
		

		char tmp_actualSign;
		char[] Satzzeichen = {'?','!',';','.'};
		
		for (int i = 0; i < tmp_Zeichenkette.length(); i++)
		{
				
			char actualSign = tmp_Zeichenkette.charAt(i);
			
			//Satzanfang
			if(i==0)
			{
				tmp_actualSign = actualSign;
				tmp_aktuellZeichenString = toUppercase(String.valueOf(tmp_actualSign)); //Umwandeln des actualSign in String und toUppercase!
				tmp_actualSign = tmp_aktuellZeichenString.charAt(0); 					//actualSign zurück in char wandeln
				
				//Gesamte Zeichenkette in 2 Hälften trennen und den ersten Buchstaben groß schreiben!
				sub_ZeichenketteLeft = tmp_Zeichenkette.substring(0, 1);
				sub_ZeichenketteRight = tmp_Zeichenkette.substring(1);
				sub_ZeichenketteLeft = tmp_aktuellZeichenString;
				tmp_Zeichenkette = sub_ZeichenketteLeft + sub_ZeichenketteRight;
			}
			
			
			if(isPunctionMark(actualSign))
			{
				
			}
		}
		
		System.out.println(tmp_Zeichenkette);
		
}}
```


----------



## Firephoenix (14. Okt 2012)

An die Leerzeichen hatte ich tatsächlich nicht gedacht.
Du kannst aber das vorgehen fast so beibehalten:
Kommst du beim drüberlaufen an einem Satzzeichen vorbei merkst du dir das in einem boolean.
Kommst du an einer Leerstelle vorbei und der besagte boolean ist true, dann weißt du das du einen Großbuchstaben erwartest und merkst dir das ebenfallst.
Alle anderen Buchstaben ignorierst du, außer du erwartest gerade einen Großbuchtsaben und der aktuelle Buchstabe ist klein.


Wenn ich deinen Code richtig interpretiere willst du aber garnicht herausfinden ob der Text falsch ist sondern ihn korriegieren oder?
Das könnest du genauso erreichen, du musst nur an den Stellen an denen der char an der Stelle i klein ist wenn du einen großen erwartest deinen Code einfügen um den char groß wieder in den String einzufügen.

Gruß


----------



## outbleeder (14. Okt 2012)

Habe es fertig bekommen.
Ich wiederhole einfach das gleiche noch einmal wie ich es bei dem 1. Zeichen mache.
Bilde Substrings usw ... 

sind am Ende 174 lines geworden.

Danke für eure Hilfe

... nächste Hausaufgabe liegt schon auf dem Tisch.:toll:


----------

