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

[monfleur]

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

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;
      
     }

 

[Fab1]

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.

 

[truesoul]

Hallo

// 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:

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;
	}

 

[xehpuk]

also hab schon die methode match() aber geht das nix ...mmmm

Hast du eine eigene Klasse String? In

java.lang.String

gibts jedenfalls nur

matches(String)

, das

boolean

zurückgibt. Aus dem

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:

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;
}

 

[hdi]

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

 

[xehpuk]

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.

s.contains("")

ergibt auch immer

true

(mal abgesehen von

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.

 

[akimoon]

Hast du eine eigene Klasse String? In

java.lang.String

gibts jedenfalls nur

matches(String)

, das

boolean

zurückgibt. Aus dem

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:

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:

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;
    }

 

[bygones]

wenn du schon n matcher nimmst, frag doch gleich [c]matcher.groupCount[/c] ab

 

[akimoon]

Die Methode stammt nicht von mir, sondern ich hab nur zitiert
Aber trotzdem muss ich zugeben, dass mir

matcher.groupCount

bisher nicht bekannt war. Wieder was gelernt

 

[ARadauer]

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

Naja meiner Meinung in diesem Fall die beste Lösung. Das ist sicher ein Anfänger Beispiel, da würde ich Regex Magie bei sowas raus halten...

 

[xehpuk]

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.

 

[FaxXer]

Also ich habe das ganze mal so gelöst:

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;
	}

 

[monfleur]

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

/**
     * 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 :

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

i

 

[FaxXer]

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.

 

[xehpuk]

na also ich folgends geschrieben :

Dann erklär mal, was du dir dabei gedacht hast. Und ob es funktioniert. Und ob du überhaupt Fragen hast.