Characters welche nicht im Array liegen ignorieren

Gibt es eine Methode welche überprüft ob ein Charakter in einem String liegt und wenn nicht diesen einfach ignoriert ?

Ich hatte an so etwas gedacht, das Problem an meinem Code ist, ich weiß nicht wie er dass Zeichen dann ignoriert und einfach in eine neue Variable speichert:

Java:
String myString = "Hal$lo";
String Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        for(int i=0; i < myString.length(); i++) {
            if(String_special[i] != Alphabet[i]) {
                i++;
            }
        }
 
Zuletzt bearbeitet:
Wenn es nur darum geht, ungültige Zeichen heraus zu filtern, dann wäre evtl. ein replace mit regulärem Ausdruck denkbar. Mit [^A-Z] würdest Du alle Zeichen finden, die nicht A-Z sind. String.replaceAll wäre dann ein Aufruf, das dann halt mit den Parametern ("[^A-Z]", "") alle ungültigen Zeichen entfernen würde.

Edit: Gross-/Kleinschreibung war falsch - A-Z muss es natürlich sein (großes Z)
 
Also es geht darum dass alle Zeichen die nicht im vorher gegebenen Alphabet gespeichert wurden ignoriert werden

den Code habe ich für den Rest mir fällt nur nicht ein wie ich die nichtvorkommenden Zeichen in einen neuen String packe:

Java:
String message = "2*21=42"; //args[1];
        int shifting = 3; //Integer.parseInt(args[2]);
        String alphabet = "0123456789+-*/";
       
        message = message.toLowerCase();
        String cipherText = "";
        for (int i = 0; i < message.length(); i++)
        {
            int charPosition = alphabet.indexOf(message.charAt(i));
            int keyVal = (shifting + charPosition) % alphabet.length();
            char replaceVal = alphabet.charAt(keyVal);
            cipherText += replaceVal;
        }
        System.out.println(cipherText);
Man könnte das hier benutzten jedoch weiß ich nicht ob man die Bedingung also die Wörter die ersetz werden sollen abhängig von einem String machen können : message = message.toLowerCase().replaceAll("\\s", "");
 
Zuletzt bearbeitet:
Du ermittelst doch die charPosition in Deinem Code.

1) Was für Werte stehen da drin für die beiden Fälle: a) Buchstabe ist im Alphabet b) Buchstabe ist nicht im Alphabet?
2) Wie man abhängig von eine Bedingung unterschiedliche Befehle ausführen kann, ist Dir bekannt?

Dann könntest Du in Abhängigkeit von dem aus 1) unter Berücksichtigung des Wissens zu 2) da in der for Schleife etwas bauen ....

(Oder eben natürlich wie in #3 kann man auch alle Zeichen aus dem Alphabet aus einem String heraus filtern, so du das nur machen willst.)
 
Ich habe folgende Abfrage welche schaut welcher den Character ausgibt welcher nicht im Alphabet ist, jedoch weiß ich nicht wie ich den ignoriere

Java:
if(charPosition == -1) {
                System.out.println(message.charAt(i));
            }
            int k
 
ignorieren bedeutet doch, dass Du den Code, der da in der for Schleife liegt, für das Zeichen nicht ausführst. Also doch etwas wie:
- Position bestimmen
- Ist Position -1 dann Ausgabe sonst anderen Code.

Ist das soweit verständlich?
 
Naja ungefähr aber habe nicht wirklich eine Ahnung wie ich es umsetze, im Grunde möchte ich ja damit bezwecken, dass der String ohne diesen Character, welcher nicht im Alphabet liegt, ausgeführt werden soll
 
Kannst Du denn folgende Aussage in Java Code übersetzen:
Wenn Bedingung1 dann:
- Befehl1
- Befehl2
sonst
- Befehl3
- Befehl4

Wie sieht das in Java aus? (Geh dabei einfach mal davon aus, dass Bedingung1 ein gültiger Boolean Ausdruck ist und Befehl1, .. Befehl4 gültige Java Anweisungen sind.
 
Sehr gut, Nun kann man das doch auf Deinen Code anwenden.

Die Bedingung ist, ob der ermittelte index -1 ist.
Wenn das der Fall ist, dann soll er das nur ausgeben.
Sonst soll er die Verarbeitung machen (Die hast Du in #4 in der Schleife nach der Ermittlung des Index.)
 
so ? :

Java:
if(charPosition != -1) {
          
            int keyVal = (shifting + charPosition) % alphabet.length();
            char replaceVal = alphabet.charAt(keyVal);
            cipherText += replaceVal;
}else {
                System.out.println(message.charAt(i));
}
 
Ja genau, so hatte ich es mir vorgestellt!

Dann bau mal den Code als Ganzes zusammen und schau, ob das Ergebnis so ist, wie Du es Dir vorstellst.
 
@Kirby_Sike ich habe Dir absichtlich nur einen kleinen Hint gegeben, weil ich dachte, Du wärst schon so weit, den Rest selbständig zu bearbeiten. Mir ist nur noch nicht klar, wo es noch hakt, daher werde ich Dich beim nächsten Problem mal nach einer Beschreibung (Algorithmus) in einfachen Worten fragen :p
 
Also mir war das mit der if else abfrage schon klar und mit der == -1 auch, nur ich hatte mir das viel zu komplex vorstellt :) deswegen passiert so etwas in meinem Kopf :) Ich denke manchmal einfach: "Niemals ist dass so einfach, dass ist bestimmt falsch"
 
Jap ist exakt das, was ich brauchte :) manchmal stelle ich mich echt blöd an
Ach was. Am Anfang ist es immer etwas schwerer, aber mit etwas Übung wird auch Dir das alles immer einfacher fallen.
Und wichtig ist auch: Du hast die Lösung selbst gefunden. Ich habe nur ein paar Mal paar kleine Zwischenschritte angefordert oder Dich etwas in die richtige Richtung "geschubst". So hat es auch einen gewissen Lerneffekt (hoffe ich zumindest).
 
Ich denke schon :) ich versuche die Sachen und Ansätze auch immer erst selbst, ich hoffe einfach dass die Unsicherheit mit der Zeit weggeht :)
 
Also mir war das mit der if else abfrage schon klar und mit der == -1 auch, nur ich hatte mir das viel zu komplex vorstellt :) deswegen passiert so etwas in meinem Kopf :) Ich denke manchmal einfach: "Niemals ist dass so einfach, dass ist bestimmt falsch"
Das nehme ich einfach einmal zum Anlass für eine kleine Ausführung:

Code ist eigentlich immer "einfach". Wenn Code nicht einfach ist, dann ist er (mehr oder weniger) falsch!

Natürlich gibt es Algorithmen, die sind sehr komplex. Aber dann muss man das so weit wie möglich vereinfachen. Ein gutes Mittel ist bei der Software-Entwicklung eben eine Aufteilung und Kapselung.
Im einfachsten Fall ist es nur eine Aufteilung in Methoden, die Komplexität kapseln.

Beispiel:
Du willst, dass der Benutzer eine Zahl eingibt.
Das kann komplex sein: Also Du fragst nach einer Zahl und prüfst. Gibt der Benutzer keine Zahl an, dann teilst Du das dem Benutzer mit und fragst erneut....
==> Dein Code wird einfacher und leserlicher, denn Du hast an der Stelle nur:
int zahl = zahlAbfragen("Bitte Zahl Eingeben");

Du prüfst auf irgendwas, z.B. Primzahl:
Code:
if (istZahlPrimzahl(zahl)) {
    System.out.println("Ist eine Primzahl!");
}
Alles leserlich. Und neben dem leserlichen Code gibt es andere Vorteile:
- Kapselung hatte ich erwähnt: Bei der Nutzung interessiert Dich nicht, wie die Routine das macht. Damit kannst Du die Implementation auch jederzeit ändern.
- Du kannst sowas auch leichter testen. Du hast halt einzelne Abschnitte, die so testbar sind.

Gibt noch mehr dazu, aber ich will nicht zu tief rein gehen. Das sollte nur ein kurzer Ausflug bezüglich "Einfach ist richtig!" sein.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben