# Anzahl bestimmter Zeichen in einem String ausgeben



## caedezz (26. Nov 2014)

Guten,

ich versuche schon etwas länger nun darauf zu kommen wie ich es schaffe die Anzahl von bestimmten Zeichenfolgen in einem vom Scanner eingelesenen String auszugeben.#

Bin in etwa so weit und frage mich nun aber wie ich es schaffe damit zu zählen.


```
public static void stringtest() {
		String input;
		CharSequence[] c;
		c = new CharSequence[3];
	
		c[0] = "string1";
		c[1] = "string2";
		c[2] = "string3";

		System.out.println("Input:");

		input = s.nextLine();
```

wie schaffe ich es nun die anzahl der verschiedenen strings im input als zahl auszugeben?


----------



## Gucky (26. Nov 2014)

Ich möchte dir nicht zu nahe treten aber ich glaube, dein Code wird dich nicht zum Ziel bringen.
Guck dir mal den StringTokenizer an.


----------



## caedezz (27. Nov 2014)

checkt ein StringTokenizer nicht einfach nur einen Token und springt dann weiter  zum nächsten?
Das würde in meinem Fall nicht helfen da die Zeichen auch ineinander verkettet sein könnten.
zB: Ich möchte folgende Eingabe "aeiou" auf das Vorkommen von "ae" "ei" "io" "ou" prüfen.
Die Ausgabe sollte dann: 4 lauten


----------



## unavailable (27. Nov 2014)

```
public class CheckOccurences{

	public static void main(String[] args){
		String[] pattern = {"ae", "ei", "io", "ou"};
		String inString = "aeiou";
		
		int count = checkForOccurences(pattern, inString);
		System.out.println(count); // 4
	}
	
	public static int checkForOccurences(String[] patternArray, String givenString){
		int occurences = 0;
		
		for(int currentIndex = 0; currentIndex < patternArray.length; currentIndex++){
			occurences += (givenString.length() - givenString.replace(patternArray[currentIndex], "").length() != 0 ? 1 : 0) ;
		}	
		return occurences;		
	}
}
```


----------



## caedezz (27. Nov 2014)

jo danke, funktioniert super für das Beispiel.
Allerdings leider nicht wenn ich zB aeaeae eingebe - das zählt er nur einmal.
Ausserdem ist die Umsetzung mit patterns etc. wahrscheinlich etwas zu fortgeschritten, da ich soweit ich weiss in der Vorlesung noch nicht gehört habe.  (uns wird nahegelegt es mit charAt() und / oder CharSequence() umzusetzen)

Habs deswegen mal so versucht: 

```
public class StringTest {

	
	public static void stringTest() {
		String test = "aeiou";
		int count = 0;

		for(int i=0; i<test.length();i++)
		{
		if (test.charAt(i) == 'a' && test.charAt(i+1) == 'e'); 
			count++; 
		if (test.charAt(i) == 'e' && test.charAt(i+1) == 'i'); 
			count++; 
		if (test.charAt(i) == 'i' && test.charAt(i+1) == 'o'); 
			count++; 
		if (test.charAt(i) == 'o' && test.charAt(i+1) == 'u'); 
			count++;
		}
		
		System.out.println(count);
	
	}
}
```

bekomm allerdings auch nur ne 1 in der ausgabe.
oder halt ne exception, da ich noch kein else drinhabe.


----------



## unavailable (27. Nov 2014)

Für nen einzelnen Wert könntest du auch folgendes benutzen:


```
public class CheckOccurences{

	public static void main(String[] args){
		String inString = "aeaeae";
		String findString = "ae";
		
		int lastIndex = 0;
		int count = 0;
		
		while(lastIndex != -1){
			lastIndex = inString.indexOf(findString,lastIndex);
			
			if(lastIndex != -1){
				count++;
				lastIndex += findString.length();
			}
		}
		System.out.println(count); // 3
	}	
}
```


----------



## caedezz (28. Nov 2014)

ajo muss ich halt nen paar while schleifen aneinanderhängen, aber passt danke


----------



## minzee (28. Nov 2014)

Für die Textsuche gibts spezielle Algorithmen:

- Knuth-Morris-Pratt
- Boyer-Moore
- Pattern-Matching

Die ersten beiden sind eher nur die Suche nach einem ganz bestimmten Inhalt. Das Pattern-Matching ist da schon etwas flexibler.

Die am einfachsten zu programmierende und am leichtesten zu verstehende Variante ist aber die Brute-Force-Variante:

```
class Main
{   
   public static void main(String[] args) 
   { 
      String txt = "aeixxxouxxxiooi";
      String[] pats = {"ae", "ei", "io", "ou"}; // Patterns

      int txtLen = txt.length(); // Textlänge
      int patLen = 2; // Pattern-Länge
      int patsCnt = pats.length; // Anzahl Patterns
      int txtLast = txtLen - patLen; // bis zu welcher Text-Stelle nach einem Pattern gesucht wird
      int cnt = 0;

      for(int txtI = 0; txtI <= txtLast ; ++txtI) // Text durchlaufen
      {
         for(int i = 0; i < patsCnt; ++i) // Pattern wählen
         {
            String pat = pats[i];
            
            // Pattern durchlaufen und Pattern-Zeichen mit Text-Zeichen vergleichen:
            int patI = 0;
            while(patI < patLen && pat.charAt(patI) == txt.charAt(txtI + patI))
            {
               ++patI;
            }
            
            if(patI >= patLen)
            {
               ++cnt;
               System.out.println("Pattern " + pat + " gefunden auf Position " + txtI + ".");
            }
         }
      }
      System.out.println("Insgesamt " + cnt + " Patterns gefunden.");
   }
}
```
Ausgabe:


> Pattern ae gefunden auf Position 0.
> Pattern ei gefunden auf Position 1.
> Pattern ou gefunden auf Position 6.
> Pattern io gefunden auf Position 11.
> Insgesamt 4 Patterns gefunden.


----------

