Klassen String - nach Wort durchsuchen

[Kel]

Ich muss eine Textdatei auslesen und den String dann nach einem bestimmten Wort durchsuchen und die Häufigkeit zählen

Bisher sieht das bei mir so aus

	private static int zahlen(String suchwort, String text) {
		int anzahl;
		int laenge = text.length();
		int hochzaehler = 0;
		for (int i = 0; i <= laenge - 1; i++) {
			if (String.contains(suchwort, text.substring(hochzaehler, i))) {
				anzahl++;
				hochzaehler = i;	
			}	
		}
		return anzahl;
	}

Es gibt laut Übung eine Methode der Klasse String, mit der man überprüfen kann, ob ein Wort in einem String enthalten ist. Ich hab aber nur "contains" gefunden, welche mir folgende Fehlermeldung in Eclipse ausspuckt:

Description Resource Path Location Type
The method contains(CharSequence) in the type String is not applicable for the arguments (String, String) Worte.java /5_2/src line 46 Java Problem

Methode "contains" ist hier String (Java Platform SE 6)

Returns true if and only if this string contains the specified sequence of char values.

Anscheinend kann ich damit aber nur nach einzelnen chars suchen und nicht nach Strings in einem String. Weiss jemand, wie ich auf ein Wort in einem String überprüfen kann?

 

[Michael...]

contains ist eine Instanzmethode und wird am String Objekt aufgerufen.
Daneben gibt's noch zwei indexOf(...) Methoden, die sogar die Stelle liefern, an der das Wort vorkommt.

 

[Kel]

/edit
Ich habe es jetzt in eine while-Schleife gepackt, ist kompakter und übersichtlicher
Er zählt aber irgendwie das erste und das letzte Wort in einer Datei nicht mit und ich verstehe nicht, wieso.

while (i <= text.length() - 1) {
			if (text.charAt(i) == ' ') {
				if (text.substring(hochzaehler, i).indexOf(suchwort) == 1) {
					anzahl++;
				}
				hochzaehler = i;
			}
			i++;

---------------------------------------------------------------
Ich hab das ganze jetzt mit indexOf(); gelöst

private static void zahlen(String suchwort, String text) {
		int anzahl = 0;
		// int "laenge" ist die Länge des Dateiinhaltes
		int laenge = text.length();
		GraphicIO.print("Der String hat die Länge: " + laenge);
		int hochzaehler = 0;
		// Schleife zum durchgehen aller chars der Datei
		for (int i = 0; i <= laenge - 1; i++) {
			// wenn ein char ein Leerzeichen ist ...
			if (text.charAt(i) == ' ') {
				// ... überprüfen, ob im Index von hochzaehler bis i das gesuchte Wort vorhanden ist
				// = Startindex des Wortes muss 0 sein, wenn das Wort am 0. Element beginnt
				if (text.substring(hochzaehler, i).indexOf(suchwort) == 0) {
					// damit nicht jedesmal wieder von Element 0 angefangen wird zu suchen
					// Indexrange beschränken auf letztes gefundenes Leerzeichen bis zum nächsten Leerzeiche
					hochzaehler = i;
					anzahl++;
				}				
			}	
		}
		//return anzahl;
		GraphicIO.print("Die Anzahl des Wortes " + suchwort + " beträgt: " + anzahl);
	}

Wenn man nach "int" sucht, wird man aber auch in "print" fündig, wie lässt sich sowas verhindern?
Ich habe es mit

if (text.substring(hochzaehler, i - 1).indexOf(suchwort) == 0)

versucht, weil der gesuchte String dann ja als 0. Element auftauchen müsste als Rückgabewert, aber wenn ich das so verwende, krieg ich gar kein Ergebnis mehr raus.

Wenn ich einen kleinen Test mache, an welcher Stelle das gesuchte Wort im Index anfängt, bekomme ich statt 0 dauernd falsche Zahlen, teilweise -1?

GraphicIO.print(text.substring(hochzaehler, (i - 1)).indexOf(suchwort));

Das ist im Grunde die einzige Stelle, wo ich grade noch hänge .

 

[suchenda]

Mehrere Möglichkeiten, die, weil recht interessant, mal gezeigt werden sollten:

indexOf:

    public static int countA(String k, String s) {
        int result = 0;
        int lastIndex = s.indexOf(k);
        while (lastIndex != -1) {
            result++;
            lastIndex = s.indexOf(k, lastIndex + k.length());
        }
        return result;
    }

Die berühmte contains (ineffektiv wegen Stringerzeugung) :

    public static int countB(String k, String s) {
        int result = 0;
        for (int i = 0; i < s.length() - k.length() + 1; i++) {
            if (s.substring(i, i + k.length()).contains(k)) {
                result++;
                i += k.length() - 1;
            }
        }
        return result;
    }

Pattern/Matcher/regex action:

    public static int countC(String k, String s) {
        int result = 0;
        Pattern p = Pattern.compile(k); // WARNUNG
        Matcher m = p.matcher(s);
        while (m.find()) {
            result++;
        }
        return result;
    }

Inkrementeller Algo, quasi wie A:

    public static int countD(String k, String s) {
        int result = 0;
        for (int i = 0; i < s.length() - k.length() + 1; i++) {
            int j = i;
            while (j < i + k.length() && s.charAt(j) == k.charAt(j - i)) {
                j++;
            }
            if (j == i + k.length()) {
                result++;
                i += k.length() - 1;
            }
        }
        return result;
    }

 

[suchenda]

achso, keine der Lösungen funktioniert mit "", ausgenommen C

B und D erzeugen wegen der Addition von -1 in der Schleife und Inkrementierung im Schleifenkopf einen recht unschönen infiniten Regress. Eben gleiches gilt für A, wo sich lastIndex nicht verändert.

 

[Kel]

Gibt es eine Möglichkeit, A so umzubauen, dass es keinen Loop gibt?
Auch bei der Suche nach einzelnen Buchstaben gibt es den gleichen Fehler.

 

[suchenda]

natürlich:

if (k == null || s == null || k.isEmpty() || s.isEmpty()) {
// werfe exception
// oder..
// gebe spezielle Wert zurück (z.B. (s.length() + 1))
}

das jedes mal zu schreiben ist natürlich viel zu schreiben und versteht sich so

nehme an, indexOf(s), wenn s.isEmpty() == true, liefert 0
man könnte nach der letzten Anweisung in der while eine Alternative in die while einfügen - das wäre nicht weniger Schreibarbeit und auch noch langsamer

Auch bei der Suche nach einzelnen Buchstaben gibt es den gleichen Fehler.

wenn k die Länge 1 hat, funktionieren alle Methoden (außer u.U. die C, weil k als regulärer Ausdruck aufgefasst und "compiliert" wird)