Aus einem String die Anzahl der Vokale auslesen

N

Nacer5

Mitglied
Ich komme hier mit meinem Code nicht weiter. Es müssen hier Vokale aus String, Array etc. ausgelesen werden. Die Methoden deklaration ist vorgegeben, sowie das bei der ersten Methode ein Array zurück gegeben werden soll.

Bei der ersten Methode habe ich die Vokale in ein Array gepackt und wollte nun das Array, Element für Element, mit den Char des String abgleichen. Am Ende soll die Anzahl der gefundenen Vokale über ein Array ausgegeben werden.

Bei der zweiten Methode soll gezählt werden wie oft ein Parameter im String vorkommt.

Methode 3 ähnelt meiner Meinung nach der ersten.

Ich habe nun etwas gebastelt, aber es läuft einfach nicht auf der Konsole. 😡 Bin hier etwas lost. Deshalb HELP! 😆

[CODE lang="java" title="Vokale"]public class Vokale {

/**
* Vokale zaehlen
*/

public static void main(String[] args) {
vokaleZaehlen("Auto");
zeichenZaehlen("Wochenende", w);
zeichenZaehlen("Wochenende", {e,m,o});
}

// Eine Methode die Vokale zählt und ausgibt.
public static int[] vokaleZaehlen (String zeichenkette){
char [] vokale = {a, e, i, o, u};
String zeichenkette = this.zeichenkette;
int [] loesung = new int[5];
for (int i = 0; i < zeichenkette.length-1; i++){
int zaehler;
for (int j = 0; j < vokale.length-1; j++){
zaehler = 0;
if (vokale == zeichenkette.charAt[j]){
zaehler ++;
loesung = zaehler;
}
}
return loesung;
}
}

/**
/ Zählt wie oft das übergebene Zeichen in der Zeichenkette vorkommt.
/ @param: Zeichenkette
/ @param: Zeichen
/ return: Anzahl Zeichen in Zeichenkette
**/
public static int zeichenZaehlen (String zeichenkette, char zeichen) {
int countChar;
String zeichenkette = this.zeichenkette;
Char [] zeichenketteChar = zeichenkette.toCharArray();
for (int i = 0; i < zeichenketteChar.length; i++){
if (zeichenketteChar == zeichen){
countChar++;
}
}
}

/**
/ Zählt wie oft die im Array übergebenen Zeichen in der Zeichenkette vorkommen.
/ @param: Zeichenkette
/ @param: Array
/ @return: Anzahl der vorkommenden Zeichen in der Zeichenkette
**/
public static int [] zeichenZaehlen (String zeichenkette, char [] zeichenArray){
String zeichenkette = this.zeichenkette;
char [] zeichenArray = this.zeichenArray;
int [] loesung = new int[zeichenArray.length];
for (int i = 0; i < zeichenkette.length-1; i++){
int zaehler;
for (int j = 0; j < zeichenArray.length-1; j++){
zaehler = 0;
if (zeichenArray == zeichenkette.charAt[j]){
zaehler ++;
loesung = zaehler;
}
}
return loesung;
}
}
} [/CODE]
 
Es wäre besser gewesen, die Frage auf drei Fragen aufzuteilen.

Die Beantwortung der ersten Frage hätte Dir sicher auch bei der Implementierung der restlichen Methoden geholfen, wodurch sich das Fragen reduziert hätte.

Ausserdem: Debuggen oder Zwischenergebnisse aus-printen.
 
Aber ich muss doch der Methode vokaleZaehlen für jedes Element aus dem String auch jedes Element aus dem Array abfragen. Deshalb erstmal die Iteration über die Länge des Strings, dann für jedes Element aus dem Array. Den Zähler benötige ich doch um später loesung = [2, 1, 0, 1, 1] oder ähnliches ausgeben zu können. Für die Zahlen im Array stehen die jeweiligen Vokale {a, e, i, o, u}.

Der Name der Methoden war vorgegeben.

Ich habe bereits versucht nur die Methoden auszuführen (die anderen hatte ich auskommentiert), aber ich muss irgendwo einen Fehler drin haben auf den ich nicht komme.
 
Nacer5 hat gesagt.:
aber ich muss irgendwo einen Fehler drin haben
Zum Vergrößern anklicken....
Du hast mehrere Fehler drin.

Die Schleifen mit i und j als Zählvariable hast Du irgendwo gefunden und dann ein bisschen

irgendwas[irgendwie}

zusammengepuzzelt.

Stell Dir ganz konzentiert (eventuell mit Hilfe Stift und Papier) vor, wie jemand, der nur die Java-Möglichkeiten hat, die Aufgabe lösen würde.
 
Hallo ich mische mich mal etwas dazu.

Dir wurde ja schon gesagt das du die Indexe i u j beim Vergleich vertauscht hast.

Auch ob hier ein Vergleich mit == richtig ist? Einen String Vergleich in Java bitte mit equels. Auch würde ich deine Vokale als String Array Speichen und nicht als cahr.
Dann sind es zwei Strings die du miteinander vergleichst.

Das mit deinem Zähler ist auch etwas sinnlos.
 
Zuletzt bearbeitet:
Jw456 hat gesagt.:
Der Methode übergibt er einen Strings formt ihn dann in cahr um. Also was ligt näher gleich alles als String zubehandeln.
Zum Vergrößern anklicken....
Es geht um einzelne Zeichen bei der Aufgabe. Also ist der direkte, naheliegende Typ auch Char. Ein String, der immer nur ein Zeichen lang ist, wäre doch unnötig komplex.

Aber man kann auch die Aufwände vergleichen: statt einfacher Char Vergleiche hättest du lauter equals Aufrufe auf Strings, die nur ein Zeichen lang sind …. Dazu die Notwendigkeit, an diese Strings zu kommen, also einige substring Aufrufe…. Oder wie würdest du an die Strings für die Vergleiche kommen?
 
Ich gebe auch mal ungefragt meine Meinung dazu.
Da da Diverses zu sagen ist, poste ich mal den Code und füge meine Kommentierung an passender Stelle ein:


Java: 
public class Vokale {

    /**
     * Vokale zaehlen
     */
    
    public static void main(String[] args) {
        vokaleZaehlen("Auto");
        zeichenZaehlen("Wochenende", w);
        zeichenZaehlen("Wochenende", {e,m,o});
    }
    
    // Eine Methode die Vokale zählt und ausgibt.
    public static int[] vokaleZaehlen (String zeichenkette){
        char [] vokale = {a, e, i, o, u};
        String zeichenkette = this.zeichenkette;
//Kommentar: Wozu diese Zuweisung? Es gibt hier in der Klasse soweit ich sehe
//ja nicht mal ein Attribut namens zeichenkette, warum nicht direkt mit dem
//übergebenen String arbeiten? Wird ja nicht verändert
        int [] loesung = new int[5];
        for (int i = 0; i < zeichenkette.length-1; i++){
            int zaehler;
//Kommentar: das mit dem zähler geht, wobei er an sich nicht erforderlich ist.
//einfach ein loesung[i]++; unten würde es auch tun. ist aber Geschmackssache
            for (int j = 0; j < vokale.length-1; j++){
                zaehler = 0;
                if (vokale[i] == zeichenkette.charAt[j]){
//Kommentar: i gehört zu zeichenkette, j zu vokale. also
//vokale[j]==zeichenkette.charAt[i]
                    zaehler ++;
                    loesung[i] = zaehler;   
                }
            }
            return loesung;
        }
    }
    
    /**
    / Zählt wie oft das übergebene Zeichen in der Zeichenkette vorkommt.
    / @param: Zeichenkette
    / @param: Zeichen
    / return: Anzahl Zeichen in Zeichenkette
    **/
    public static int zeichenZaehlen (String zeichenkette, char zeichen) {
        int countChar;
        String zeichenkette = this.zeichenkette;
        Char [] zeichenketteChar = zeichenkette.toCharArray();
        for (int i = 0; i < zeichenketteChar.length; i++){
            if (zeichenketteChar[i] == zeichen){
                countChar++;
            }
        }   
//Kommentar return countChar; fehlt
    }

    /**
    / Zählt wie oft die im Array übergebenen Zeichen in der Zeichenkette vorkommen.
    / @param: Zeichenkette
    / @param: Array
    / @return: Anzahl der vorkommenden Zeichen in der Zeichenkette
    **/
    public static int [] zeichenZaehlen (String zeichenkette, char [] zeichenArray){
//hier wäre es generell sehr sinnvoll, auf die schon definierte Methode
//zeichenZählen(...) zurückzugreifen
//Aus dem string ein char[] zu machen, wie eben auch in der Methode eben,
//wäre recht sinnvoll
//ich würde die ganzen zeilen mit this weglassen.
//es gibt ka keine entsprechenden Attribute und du änderst auch die übergebenen Arrays nicht,
//also brauchts die zeilen auch nicht
        String zeichenkette = this.zeichenkette;
        char [] zeichenArray = this.zeichenArray;
        int [] loesung = new int[zeichenArray.length];
        for (int i = 0; i < zeichenkette.length-1; i++){
            int zaehler;
            for (int j = 0; j < zeichenArray.length-1; j++){
                zaehler = 0;
                if (zeichenArray[i] == zeichenkette.charAt[j]){
                    zaehler ++;
                    loesung[i] = zaehler;   
                }
            }
            return loesung;
        }
    }
}
Java:
 
Wenn jetzt davon ausgegangen wird, dass die Fehler genannt wurden, dann frage ich mich, wieso ein offensichtlicher Fehler wie die nicht korrekt dargestellten char-Literale, nicht erwähnt wurde.

An mehreren Stellen sollen anscheinend char Literale verwendet werden. Beim Aufruf der Methode aber auch in der Methode zum Vokale zählen:
char [] vokale = {a, e, i, o, u};

a, e, i, o und u sind hier jetzt Bezeichner und keine char Literale.
 
char [] vokale = {a, e, i, o, u};
stimmt eigentlich will er den Ascii Code vergleichen 'a' = 61h

das hätte auch einen Compiler Fehler geben müssen.

Groß klein Schreibung beachtet er hier auch nicht.

char [] vokale = {'a', 'e', 'i', 'o', 'u'};

Das mit dem return müsste auch zu einem Compiler Fehler füren .

Warten wir mal was der TE dazu sagt.
 
Generell möchte ich einmal auf einen Kommentar von @berndoa eingehen:
//hier wäre es generell sehr sinnvoll, auf die schon definierte Methode
//zeichenZählen(...) zurückzugreifen
Zum Vergrößern anklicken....
Das ist generell zu beachten. Nutzt die Methoden, die Vorhanden sind:

Dann fangt ihr an:
- Eine Methode, die die Anzahl eines Zeichens in einem String zählt.
- Dann könnt ihr eine Methode schreiben, die ein Array von Zeichen entgegen nimmt und dann für jedes Element dieses Arrays die vorhandene Methode aufruft.
- Wenn ihr dann zu der Vokale zählen Methode kommt, dann ist das einfach nur ein Aufruf der oberen Methode mit allen Vokalen als zweiten Paramete.

Und das ist dann auch das Vorgehen, das ich jedem empfehle: Teilt Code auf! Vermeidet Verschachtelungen, die zu tief sind! Vermeidet schlechte Bezeichner!

i und j vertauscht -> Wäre leicht zu sehen, wenn die Namen ordentlich gewählt worden wären (vokaleIndex für die Iteration über das vokale Array z.B.) Und es wäre unmöglich gewesen, wenn es keine zwei verschachtelten Schleifen gegeben hätte!

return Statment ist in einer Methode in der Schleife - das ist natürlich auch Quatsch und fällt auf, wenn Methoden nur ganz weniger Zeilenmit kleiner Einrücktiefe haben!

Das ist etwas, das ihr beachten solltet!

Hier sind Methoden schon vorgegeben, die man einfach implementieren kann. Aber auch sonst ist es ratsam, Dinge direkt zu unterteilen. Also wie gehe ich bei sowas vor?

Ich soll eine Methode schreiben:
public static int[] vokaleZaehlen (String zeichenkette) {

Also erste Überlegung: Was bekomme ich, was soll zurück gegeben werden?

Das führt dann direkt zu dem Zwischenstand:
Java: 
    public static int[] vokaleZaehlen (String zeichenkette) {
        char [] vokale = {'a', 'e', 'i', 'o', 'u'};
        int [] loesung = new int[vokale.length];
        
        // ...
        
        return loesung;
    }
Was habe ich eingbaut?
- Eingabe verifiziert / vervollständigt.
- Etwas für die Lösung parat gestellt.

Nun muss ich nur noch die loesung befüllen:

Java: 
    public static int[] vokaleZaehlen (String zeichenkette) {
        char [] vokale = {'a', 'e', 'i', 'o', 'u'};
        int [] loesung = new int[vokale.length];
        
        for (int i = 0; i < vokale.length; i++){
            loesung[i]=zeichenZaehlen(zeichenkette, zeichenArray[i]);
        }
        
        return loesung;
    }

Das ist der Ansatz unabhängig davon, ob das zeichenZaehlen vorgegeben ist oder nicht! Denn ich übersetze überlegungen 1:1 in Code. Denn so ist der Code auch leichter lesbar:

Die Überlegung ist doch: Für jeden Vokal zähle ich, wie oft dieses Zeichen vorkommt. Und das ist doch nun auch relativ einfach ablesbar.

Das ist eine Sache, die aus meiner Sicht existenziell ist! gerade für Anfänger! Leute, die 40h die Woche Software Entwickeln, machen sowas, damit Code auf einen Blick lesbar ist. Da sollte es für einen Anfänger doch um so wichtiger sein, das ebenso zu machen!
 
kneitzel hat gesagt.:
Wenn jetzt davon ausgegangen wird, dass die Fehler genannt wurden, dann frage ich mich, wieso ein offensichtlicher Fehler wie die nicht korrekt dargestellten char-Literale, nicht erwähnt wurde.

An mehreren Stellen sollen anscheinend char Literale verwendet werden. Beim Aufruf der Methode aber auch in der Methode zum Vokale zählen:
char [] vokale = {a, e, i, o, u};

a, e, i, o und u sind hier jetzt Bezeichner und keine char Literale.
Zum Vergrößern anklicken....
Also ich habe nahc wie vor den unterschied zwischen den verkorksten Literalen und den normalen char Teilen nicht verstanden und halte mich daher dezent raus weils für mich immer noch nach Esoterik aussieht 🙂
 
berndoa hat gesagt.:
Also ich habe nahc wie vor den unterschied zwischen den verkorksten Literalen und den normalen char Teilen nicht verstanden und halte mich daher dezent raus weils für mich immer noch nach Esoterik aussieht
Zum Vergrößern anklicken....
Ein Literal ist einfach ein Stück Quelltext, das einen Wert eines bestimmten Datentyps darstellt. Eine 42 im Quelltext ist in Java ein int-Literal, ein 'x' ein char-Literal, ein x ist dagegen ein einfacher Bezeichner.

In der Zeile char [] vokale = {a, e, i, o, u}; sind also a, e, i, o und u Bezeichner und keine char-Literale. Für char-Literale müssten die Buchstaben in Hochkommas stehen.
 
Wie oft denn noch der TE hat es nicht in einfache Hochkomma gesetzt. Schaue einfach zurück.

Übrigens es gibt einfache und doppelte Hochkomma.
 
Es gibt einfache Hochkommatas - da hat man dann ein char. Also z N. 'a'

Und es gibt die doppelten, die dann einen String Literal erzeugen, also z.B. "a".

Das findet man auch im Detail im Abschnitt Literale der Java Language Specification (Incl. genauem Unicode deS zu verwendeten Zeichens.)
 
Huh, gut zu wissen.
Solche Haarspaltereien gibt es in anderen Sprachen nicht, ob ' ' oder " ", dort ist Alles ein String was keine Zahl und kein Bool ist 🙂


Da bleibt man doch am Besten konsequent bei Strings, dann muss man sich mit so unnötigem Kleinkram nicht rumschlagen 🙂
 
zur Info ein CHAR kannst du mit einfachen oder doppelten Hochkomma schreiben.

char x = "a";
char x = 'a';

ist das gleiche.

Strings nur mit doppelten.
 
Generell hat da jeder seine Sichtweise und das ist auch ok. Und diverse Sprachen machen dies unterschiedlich. Aber meine Sichtweise hier ist:
berndoa hat gesagt.:
Solche Haarspaltereien gibt es in anderen Sprachen nicht, ob ' ' oder " ", dort ist Alles ein String was keine Zahl und kein Bool ist 🙂
Zum Vergrößern anklicken....
Also das halte ich nicht für gut. Auch in anderen Sprachen gibt es da durchaus wichtige Unterschiede. Eine Sprache, die nicht zwischen char und String Literalen unterscheiden kann, halte ich für nicht gerade unproblematisch, denn das sind halt zwei Paar Schuhe. (Und führt dann zu Konstrukten wie "a".codeUnits.first; (dart) oder so ...)

Und wenn dann eine Sprache Feinheiten hat, wie beides sind Strings und bei einer Variante werden Variablen ersetzt und bei der anderen nicht oder so halte ich auch nicht gerade für förderlich.

Aber da hat jeder seine Präferenzen. Aber dieses Vorgehen bei Java finde ich erst einmal in Ordnung.
 
Jw456 hat gesagt.:
zur Info ein CHAR kannst du mit einfachen oder doppelten Hochkomma schreiben.

char x = "a";
char x = 'a';

ist das gleiche.

Strings nur mit doppelten.
Zum Vergrößern anklicken....
Wie kommst Du auf diese Idee? Das ist natürlich falsch.
JLS 3.10.4:
A character literal is expressed as a character or an escape sequence (§3.10.7), enclosed in ASCII single quotes. (The single-quote, or apostrophe, character is \u0027.)
Zum Vergrößern anklicken....
JLS 3.10.5
A string literal consists of zero or more characters enclosed in double quotes
Zum Vergrößern anklicken....
Damit sind die Typen des Literals klar vorgegeben und ein String ist nicht in einen char castbar.
Daher kommt dann auch bei einem solchen Versuch:
java: incompatible types: java.lang.String cannot be converted to char
Zum Vergrößern anklicken....
 
Jw456 hat gesagt.:
zur Info ein CHAR kannst du mit einfachen oder doppelten Hochkomma schreiben.

char x = "a";
char x = 'a';

ist das gleiche.

Strings nur mit doppelten.
Zum Vergrößern anklicken....
Also ich habe bisher immer

String x="a"; geschrieben und nie hat es wen gesteuert, geschweigedenn dieser unnötige Kram von literalen, bezeichnern und ähnlichem Nerdkram 🙂


Wobi ich da generell eh nicht sauber arbeit und aus einem Char mit String p=x+"" auch einmal mal quick und dirty einen String bastle.
Insofern bin ich da sicher kein gutes Vorbild 🙂
 
berndoa hat gesagt.:
Also ich habe bisher immer
char x = "a";
und
String x="a"; geschrieben und nie hat es wen gesteuert
Zum Vergrößern anklicken....

Also das erste mit char sollte den Compiler stören 🙂

Schauen wir einfach einmal, was so die einfachen Versuche dazu sagen:
Code: 
C:\Temp>javac Test.java
Test.java:2: error: incompatible types: String cannot be converted to char
  char ch = "x";
            ^
1 error

C:\Temp>type Test.java
public class Test {
  char ch = "x";
}
C:\Temp>java -version
openjdk version "16.0.1" 2021-04-20
OpenJDK Runtime Environment AdoptOpenJDK-16.0.1+9 (build 16.0.1+9)
OpenJDK 64-Bit Server VM AdoptOpenJDK-16.0.1+9 (build 16.0.1+9, mixed mode, sharing)

C:\Temp>d:\Apps\java8.bat 

C:\Temp>javac Test.java   
Test.java:2: error: incompatible types: String cannot be converted to char
  char ch = "x";
            ^
1 error

C:\Temp>java -version     
openjdk version "1.8.0_292"
OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_292-b10)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.292-b10, mixed mode)

C:\Temp>
 
Jw456 hat gesagt.:
dann halt
char x = 0x61; // a
Zum Vergrößern anklicken....
Ich habt natürlich Recht, dass es da viele Wege gibt, die möglich sind.

Aber vielleicht ist es interessant, wenn wir den oberen Fall etwas unter die Lupe nehmen. (Vielleicht auch nicht - nicht jeder ist so verrückt nach JLS wie ich 🙂 )

0x61 ist ein int Literal nach JLS 3.10.1:
An integer literal may be expressed in decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2).
Zum Vergrößern anklicken....
An integer literal is of type long if it is suffixed with an ASCII letter L or l (ell); otherwise it is of type int (§4.2.1).
Zum Vergrößern anklicken....
Bei einem int ist kein impliziter cast möglich, so dass es eigentlich ein expliziter cast sein müsste. Denn wenn wir das umschreiben, dann sehen wir: bei einem int Wert haben wir ein Problem bei der Zuweisung (Also einfach erst eine Zuweisung zu einer int Variable):

Java: 
C:\Temp>javac Test.java   
Test.java:3: error: incompatible types: possible lossy conversion from int to char
  char ch = i;
            ^
1 error

C:\Temp>type Test.java   
public class Test {
  int i = 0x61;
  char ch = i;
}
C:\Temp>

Daher ist die Frage, wieso dies hier zugelassen wird. Das findet sich natürlich auch weiter in der JLS und zwar im Bereich 5.2, wenn es um Zuweisungen geht:
In addition, if the expression is a constant expression (§15.29) of type byte, short, char, or int:
  • A narrowing primitive conversion may be used if the variable is of type byte, short, or char, and the value of the constant expression is representable in the type of the variable.
Zum Vergrößern anklicken....
Das kann man dann auch direkt testen: Sobald ich das ändere zu final int i = 0x61;, dann ist es wieder ok.

Jw456 hat gesagt.:
ok sorry kabe mich geirrt.

char x = 'a'; einfache Hochkomma ist richtig
war noch in PHP
Zum Vergrößern anklicken....
Das ist überhaupt kein Problem. An der Tatsache, dass ich das ja auch schnell getestet hatte, ehe ich dazu sozusagen aufgefordert wurde und auch an der kleinen Exkursion hier, zeigt ja auch, dass man leicht etwas übersieht. Einzelne Stellen könnten den Verdacht aufkommen lassen, dass etwas problematisch ist und dann wird es an anderer Stelle explizit erlaubt.
 
Code: 
JSR-0815
========
Description: The Java Language Specification is outdated and needs to be renamed.
Nobody calls it JLS anymore, nobody but @kneitzel reads it anymore. 

Spec Lead: @kneitzel 

Blabla

Section 2: Request
2.1 Abbreviate the Java Language Specification by KLS.
Is ja mal ein Anfang.
 
Herzlichen Dank für all eure Antworten. Das hat mir unheimlich geholfen und nun funktioniert mein Code auch, auch wenn ich eine Weile basteln musste. Wahrscheinlich ist er noch verbesserungswürdig, aber ich bin froh das es keine Fehler gibt. 😄Grad als Anfänger kann einem sowas wie diese einfachen oder doch doppelten Anführungszeichen doch sehr verwirren. 🙂
[CODE lang="java" title="Vokale"]public class Vokale {

/**
* Vokale zaehlen
*/

public static void main(String[] args) {
vokaleZaehlen("bald sind ferien");
System.out.println();
zeichenZaehlen("friede freude eierkuchen", 'i');
System.out.println();
zeichenZaehlen("heute ist ein schoener tag", new char[]{'l','a'});
}

/** Eine Methode die Vokale zählt und ausgibt.**/
public static int[] vokaleZaehlen (String zeichenkette){
char [] vokale = {'a', 'e', 'i', 'o', 'u'};
int lengthVokale = vokale.length;
int [] loesung = new int[5];
zeichenkette.toLowerCase();
for (int i = 0; i < lengthVokale; i++){
for (int j = 0; j < zeichenkette.length(); j++){
if (vokale == zeichenkette.charAt(j)){
loesung++;
}
}
}
System.out.println("Methode 1: Die Anzahl der Vokale \"a, e, i, o, u\" im Satz >" + zeichenkette + "< betraegt: " + java.util.Arrays.toString(loesung) + ".");

return loesung;
}

/**
/ Zählt wie oft das übergebene Zeichen in der Zeichenkette vorkommt.
/ @param: Zeichenkette
/ @param: Zeichen
/ return: Anzahl Zeichen in Zeichenkette
**/
public static int zeichenZaehlen (String zeichenkette, char zeichen) {
int countChar = 0;
char [] zeichenketteChar = zeichenkette.toCharArray(); // String in Char umgewandelt
zeichenkette.toLowerCase();
for (int i = 0; i < zeichenketteChar.length; i++){
if (zeichenketteChar == zeichen){
countChar++;
}
}
System.out.println("Methode 2: Das uebergebene Zeichen " + zeichen + " kommt " + countChar + " mal in \"" + zeichenkette + "\" vor.");
return countChar;
}

/**
/ Zählt wie oft die im Array übergebenen Zeichen in der Zeichenkette vorkommen.
/ @param: Zeichenkette
/ @param: Array
/ @return: Anzahl der vorkommenden Zeichen in der Zeichenkette
**/

public static int [] zeichenZaehlen (String zeichenkette, char [] zeichenArray){
int [] loesung = new int[zeichenArray.length];
zeichenkette.toLowerCase();
for (int i = 0; i < zeichenArray.length; i++){
for (int j = 0; j < zeichenkette.length(); j++){
if (zeichenArray == zeichenkette.charAt(j)){
loesung++;
}
}
}
System.out.println("Methode 3: Im Array >" + zeichenkette + "<" );
for (int y = 0; y<zeichenArray.length; y++){
System.out.println("- das Zeichen " + zeichenArray[y] + " kommt " + loesung[y] + " mal vor.");
}
return loesung;
}
} [/CODE]
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Vokale in einem String überprüfen mittels Rekursion
Antworten: 8
Vokale aus String zählen
Antworten: 19
vokale konsonanten ziffern satzzeichen aus string lesen. hab kiene ahnung
Antworten: 10
Vokale aus String entfernen
Antworten: 11
Klassen Anzahl sowie die Anzahl der Junit Tests ermitteln?
Antworten: 8

Zurück
Oben