Buchstabenabgleich

Java-Forum Java-Grundlagen
1

Hey Leute,

mein Problem ist folgendes, ich würde gerne einen String nach Vokalen überprüfen und jedes mal den Zähler erhöhen wenn einer gefunden wird. Das geht soweit auch in Ordnung, jedoch ist mir diese Schreibweise zu lang.

public static int anzahlvokale(String s){
	
		int len = s.length();
		int vokale = 0;
		for (int i=0;i<len;i++){
	              
	        if (s.charAt(i) == 'a' ) vokale++;
	        if (s.charAt(i) == 'e' ) vokale++;
	        if (s.charAt(i) == 'i' ) vokale++;
	        if (s.charAt(i) == 'o' ) vokale++;
	        if (s.charAt(i) == 'u' ) vokale++;
		}
	
	return vokale;
        }

Ich habe jetzt in diese Richtung gedacht…

if (s.charAt(i) == 'a' , 'e' , 'i' , 'o' , 'u' ) vokale++;

Mein Compiler sagt mir jedoch die ganz Zeit, dass es zu einem Syntaxfehler. Ich habe jetzt schon ziemlich lange gesucht, finde aber einfach keine passende Lösung die char’s aneinander zu hängen.

(Vllt bin ich auch einfach zu blöd zum Suchen, aber als Anfänger lassen sich Probleme eher schwer exakt benennen)

2

Du kannst die Abfragen mit || - ODER verknüpfen if(bedingung || bedingun… etc.)

oder du machst es gleich mit ner Liste:

		Character[] arr = {'a', 'b', 'c'};
        List<Character> characters  = Arrays.asList(arr);
        String wort = "adcasdab";
        int zaehler = 0;
        for(Character buchstabe : wort.toCharArray()){
        	if(characters.contains(buchstabe)){
        		zaehler++;
        	}
        }
        System.out.println(zaehler);
    }```
3

Lesbarer wird es, wenn du für den Vokal-Check eine eigene Methode definierst:

    return c=='a' || c=='e' || c=='i' || c=='o' || c=='u';
}```

In der Schleife sieht das dann so aus:
```if (isVokal(s.charAt(i))) {
   vokale++;
} ```
4

Die Lösung von Timme finde ich durchaus angebracht. Ist prima lesbar- und wartbar, und das ist bisweilen wichtiger als ein möglichst kurzer Sourcecode. :slight_smile:

pl4gu33s Lösungsvorschlag ließe sich noch etwas vereinfachen (imho) zu

    int vokale=0;
    for(int i=0; i<s.length(); i++) {
        if("aeiouAEIOU".contains(s.substring(i, i+1))) {
            vokale++;
        }
    }

Aber wenn es unbedingt kurz sein muss, dann wäre es wohl am einfachsten mit einem RegEx alle Nicht-Vokale rauszuwerfen und die verbleibenden Zeichen zählen zu lassen. Solche Loesungen sollte man dann aber mit einem erklärenden Kommentar versehen, denn sowas kann sehr schnell ins schwer lesbare ausarten.

    // anzahl der Vokale im String ermitteln
    int vokale = s.replaceAll("[^aeiouAEIOU]","").length();
5

Oder du verwendest

// ...
// und dann
VOCALS.contains(someChar)```
Aber da muss halt ueber die Wrapperklasse gearbeitet werden...
6

Die von tfa würde ich auch anwenden, meistens ist es lesbarerer solche Sachen in eine eigene Methode auszulagern.

Oder eben wie pl4gu33 es vorgeschlagen hat, mit einer ODER-verknüpfung (||) in der if. Wobei man s.charAt(i) in eine variable stecken könnte

char c = s.charAt(i);
if (c == 'a' || c == 'i' ... )
7

if ("aeiou".indexOf(s.charAt(i)) != -1) zaehler++;

8

ich hab auch noch einen:Patter selbstlautePattern = Pattern.compile("a|e|i|o|u",Pattern.CASE_INSENSITIVE); Matcher selbstlauteMatcher = selbstlautePattern.matcher(s); while(selbstlauteMatcher.find()){ zaehler++; }
bye
TT

9

@Timothy_Truckle
Pattern.compile("[aeiou]",Pattern.CASE_INSENSITIVE);
:wink:

10

Erstmal vielen Dank für die Antworten, dank euch hab ich’s jetzt;)
Die Oder-Verknüpfung( || ) hab ich auch versucht, aber leider falsch gemacht. Hab mich jetzt für sie entschieden…
Diesmal in richtig :slight_smile:

11

Moin,

[QUOTE=Dow_Jones;26803]Die Lösung von Timme finde ich durchaus angebracht. Ist prima lesbar- und wartbar, und das ist bisweilen wichtiger als ein möglichst kurzer Sourcecode. :slight_smile:
[/QUOTE]
Dem möchte ich dann doch noch widersprechen!
Lesbar - ok, aber reichlich ineffizient !!

Wenn das zu prüfende Zeichen bspw. ein ‚a‘ ist, warum sollte ich dann jedesmal noch 4 weitere Zeichen prüfen ?
Die Lösung von MiMi ist sicher genauso gut lesbar, aber ebeen effizient (und das hat nichts mit kurzem Code zu tun) :slight_smile:

Gruß
Klaus

12

Pfft, wenn man eh nur die 5 Vokale checkt ist das immer noch O(n). Konstante Vorfaktoren interessieren nicht. :stuck_out_tongue:
Grundsätzlich stimme ich dir aber zu, Codeästhetik hin oder her.

Das Ganze bringt mich aber auf einen anderen Gedankengang: Wie sollte man Umlaute und Ligaturen zählen? Ist ein „ä“ ein Vokal? Oder zwei Vokale, wenn man es als „ae“ schreibt? Und verwendet überhaupt irgendjemand Ligaturen wie Æ, œ, ?, ??? Ich selbst habe sie noch nie genutzt.

13

Gibt es die überhaupt in der deutschen Sprache?

14

Keine Ahnung ob sie im Duden stehen, aber beim Buchdruck sind sie ganz normal. Java bzw. Unicode kennt sie ebenfalls. Warum sollte man sie also nicht verwenden? Oder sie zumindest bei Input aus unbekannter Quelle berücksichtigen? Aus irgendeinem Grund scheint sich jedoch kein Softwareentwickler darum zu schehren. Beispiel: Als ich das Posting schrieb wurden die Ligaturen für „ij“ und „fi“ korrekt dargestellt. Jetzt, beim Lesen des fertigen Threads, erscheint da bei mir für ij ein „?“ und bei fi ein „???“.
Hmm. Soweit ich weiss wurden die Ligaturen schon im Mittelalter von den bibelabschreibenden Mönchen „erfunden“ - und Opera unter Windows bekommt das offensichtlich heute noch nicht richtig hin. Und da heisst es immer die Computertechnik würde sich ach so schnell weiterentwickeln… :smiley:

15

Deshalb gibt es ja LaTeX mit speziell dafür entwickelten Schriftarten :wink: Aber Recht hast du, im Hausgebrauch ist Textsatz (zumindest unter Windows kann ich das beurteilen) eine Katastrophe. Toll sind auch einzelne fett erscheinende Buchstaben, die plötzlich nicht mehr fett sind, wenn man sie anders skaliert…

16

Ligaturen wie Æ, œ

kenne ich aus dem Dänischen. Es gibt auch noch das durchgestrichene o und das a mit Kringel drüber.

Je nach Sprache des Textes solltest du die wohl mitzählen, bei deutschen Texten würde ich sie nicht mitzählen.

Ein Streitfall ist immer das y. Kein herkömmlicher Vokal, aber auch kein wirklicher Konsonant.