Methoden String methoden ,Häufigkeit einm wort in der Zeichenkette

monfleur

Mitglied
hallo leute !!...
ich suche eine string methode , mit der d anzahl , wie häufig die teilkette in der Zeichenkette enthalten ist zrückgegeben wrd ....
also hab schon die methode match() aber geht das nix ...mmmm
Java:
public StringBearbeitung()
    {
    // Eine Zeichenkette für alle Fälle
        zeichenkette = new String("Wenn Fliegen hinter Fliegen fliegen Fliegen hinter Fliegen her");
    }
    

     /**
     * Gibt zurück, wie häufig eine übergebene Zeichenkette in dieser Zeichenkette
     * enthalten ist.
     * @param teilKette Die Zeichenkette die enthalten sein soll.
     * @return Die Anzahl, wie häufig die teilkette in der Zeichenkette enthalten ist.
     */
     public int anzahlVorkommen(String teilkette)
    {   
     
       return zeichenkette.match(teilkette).length;
      
     }
 
Du könntest den String mit split(); beim Leerzeichen teilen. Daraus erhältst du ein Array, welches du mit einer Schleife durchlaufen lässt und jedes mal, wenn die Teilkette dem Arrayindex entspricht (equal) dann zählst du eine Variable um eins hoch. Am Schluss gibst du die Variable zurück und gut ist.

Gibt, vielleicht auch etwas einfacheres aber funktionieren würde es.
 
Hallo

Java:
// Anzahl aller Fliegen ( nicht fliegen )
// Ansonsten toLowerCase() verwenden
System.out.println( (zeichenkette .split("Fliegen").length)-1 );

Wenn es um solche Sätze handelt reicht das vollkommen aus.

Ansonsten:

Java:
public int getSum(String text, String regex){
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(text);
		int count = 0; 
		while(m.find()){
			count++;
		}
		
		return count;
	}
 
also hab schon die methode match() aber geht das nix ...mmmm
Hast du eine eigene Klasse String? In
Code:
java.lang.String
gibts jedenfalls nur
Code:
matches(String)
, das
Code:
boolean
zurückgibt. Aus dem
Code:
length
hinten dran werde ich auch nicht schlau.

Reguläre Ausdrücke sind hier Overkill. Die braucht man nur, wenn man reguläre Ausdrücke braucht. 😉
Das ist hier nicht gegeben.

Mein Vorschlag:
Java:
static int count(final String a, final String b) {
	final int l = b.length();
	if (l == 0)
		return a.length() + 1;
	int n = 0;
	for (int i = 0; (i = a.indexOf(b, i)) != -1; i += l, n++);
	return n;
}
 
Java:
final int l = b.length();
if (l == 0)
      return a.length() + 1;

Hö, warum denn das? Man kann sich ja drüber streiten ob man ein nicht-vorhandenes Zeichen als Wildcard für jedes beliebige Zeichen interpretiert, aber wieso dann a.length() + 1? In einem String mit Länge x kann unmöglich x+1 mal ein bestimmtes/beliebiges Zeichen vorkommen.

Eher Sinn machen würde return 0 / throw IllegalArgumentException.

PS: Aber krasse Schleife, das muss ich schon sagen 🙂
 
Beim Leerstring gibts wohl ein wenig Interpretationsspielraum.

Nach meinem Verständnis passt er, wie ein Caret, zwischen die Zeichen. In den Leerstring selbst passt er also einmal, in den String "a" zweimal (vors a, hinters a), in den String "ab" dreimal (vors a, zwischen a und b, hinters b) etc., also Länge+1.
Code:
s.contains("")
ergibt auch immer
Code:
true
(mal abgesehen von
Code:
s == null
).

Andererseits könnte man es wie "Wie oft passt die 0 in die Zahl x?", also x/0 auffassen. Dann wiederum müsste unendlich rauskommen oder eher eine Exception geworfen werden.
 
Hast du eine eigene Klasse String? In
Code:
java.lang.String
gibts jedenfalls nur
Code:
matches(String)
, das
Code:
boolean
zurückgibt. Aus dem
Code:
length
hinten dran werde ich auch nicht schlau.

Reguläre Ausdrücke sind hier Overkill. Die braucht man nur, wenn man reguläre Ausdrücke braucht. 😉
Das ist hier nicht gegeben.

Mein Vorschlag:
Java:
static int count(final String a, final String b) {
	final int l = b.length();
	if (l == 0)
		return a.length() + 1;
	int n = 0;
	for (int i = 0; (i = a.indexOf(b, i)) != -1; i += l, n++);
	return n;
}
Was spricht hier gegen reguläre Ausdrücke? Also ich finde den Code damit wesentlicher Übersichtlicher und denke, dass er auch schneller ausgeführt wird sobald die Strings länger werden. Bei deiner Methode muss ich selbst erst überlegen, was er genau macht und wie er funktioniert. Da finde ich das folgende doch schlanker/einfacher:
Java:
public int getSum(String text, String regex){
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(text);
        int count = 0; 
        while(m.find()){
            count++;
        }
        
        return count;
    }
 
Die Methode stammt nicht von mir, sondern ich hab nur zitiert 🙂
Aber trotzdem muss ich zugeben, dass mir
Java:
matcher.groupCount
bisher nicht bekannt war. Wieder was gelernt 🙂
 
Was spricht hier gegen reguläre Ausdrücke? Also ich finde den Code damit wesentlicher Übersichtlicher und denke, dass er auch schneller ausgeführt wird sobald die Strings länger werden.
Ich denke, dass es immer langsamer ist. Regex sind nicht so kostengünstig. Außerdem muss man den Suchstring nochmal durch [c]Pattern#quote(String)[/c] jagen, wenn man ihn mit Sicherheit nur "plain" haben will.
 
Also ich habe das ganze mal so gelöst:

Java:
public static int countWords(String text, String word){
		int count=0;
		Pattern pat = Pattern.compile(Pattern.quote(word));
		Matcher m;
		for(m = pat.matcher(text); m.find(); count++);
		return count;
	}
 
hey ,
also wie gesagt ,diese methode soll einfach sein ,und zwar regex ist hier nicht gebraucht ..
im aufgabe ist folgendes ::
Die Klasse StringBearbeitung enthält zahlreiche Methodenentwürfe, deren Implementierung
noch fehlt. Ergänzen Sie den zugehörigen Programmcode. Verwenden Sie dazu Methoden
der Klasse String.

also hier muss ich diese methode nur ergänzen


Java:
/**
     * Gibt zurück, wie häufig eine übergebene Zeichenkette in dieser Zeichenkette
     * enthalten ist.
     * @param teilKette Die Zeichenkette die enthalten sein soll.
     * @return Die Anzahl, wie häufig die teilkette in der Zeichenkette enthalten ist.
     */
     public int anzahlVorkommen(String teilkette)
    {


na also ich folgends geschrieben :

Java:
public int anzahlVorkommen(String teilkette)
    {   
     
      
      int count = 0;
      while(zeichenkette.contains(teilkette))
      { 
         if (zeichenkette.contains(indexOf(teilkette)))
          
          count++;
      }
      return count;
     }





i
 
Und das funktioniert?

Das wäre doch eigentlich eine Endlosschleife, da contains ja nicht am Ende der Zeichenkette aufhört sondern vorne wieder anfängt?! Ausserdem erwartet contains doch eine CharSequence und keine indexOf Angabe also int.
 

Neue Themen


Zurück
Oben