Regex und .matches() geben keine Ausnahme

[Nooobi]

Hallo, ich bin noch so ziemlich ein Anfänger und verstehe wieso mein Code hier nicht funktionieren will.
Ich würde gerne eine IPv6-Adresse auf ihre gültigkeit überprüfen und wollte überprüfen ob in einem String, andere Symbole zwischen 0-9 und a-f existieren. Ich poste hier den Code.

Frage: Wieso sagt er "x" wäre ein gültiges Symbol?!

Ich würde mich über eine schnelle Antwort freuen, da Ich morgen eine Arbeit darüber schreibe

Code:

package Ipv6test;


public class IPTEST {
    // Main Methode
    public static void main(String[] args) {
        String IPv6Screen1 = "fe80:f3x:ACBA:0000:2341:CCBA:A278:04B1";
        String IPv6Screen = IPv6Screen1.toLowerCase();
        // Aufrufen von Methoden
        Check(IPv6Screen);
    }
    // Methode zum Abfragen ob der IPv6 String gültig ist
    public static void Check(String IPv6Screen) {
        String split[] = IPv6Screen.split(":", 8);
    
        // Check in Schleife
        for (String s : split) {
            if (s.length() > 4) {
                System.out.println(s + " Ist länger als 4 Zeichen -> Ungültig");
            } else {
             if (s.matches("[^0-9a-f]")) {
                    System.out.println(s + " Enthält ungültige Symbole -> Ungültig");
                } else {
                    System.out.println(s + " Enthält korrekte Symbole");
                }
            }
        }
    }
}

Ausgabe:

fe80 Enthält korrekte Symbole
f3x Enthält korrekte Symbole
acba Enthält korrekte Symbole
0000 Enthält korrekte Symbole
2341 Enthält korrekte Symbole
ccba Enthält korrekte Symbole
a278 Enthält korrekte Symbole
04b1 Enthält korrekte Symbole

 

[temi]

Verwende bitte die Codetags (das </> Symbol im Editor).

public class IPTEST {
    // Main Methode
    public static void main(String[] args) {
        String IPv6Screen1 = "fe80:f3x:ACBA:0000:2341:CCBA:A278:04B1";
        String IPv6Screen = IPv6Screen1.toLowerCase();
        // Aufrufen von Methoden
        Check(IPv6Screen);
    }
    
    // Methode zum Abfragen ob der IPv6 String gültig ist
    public static void Check(String IPv6Screen) {
        String split[] = IPv6Screen.split(":", 8);

        // Check in Schleife
        for (String s : split) {
            if (s.length() > 4) {
                System.out.println(s + " Ist länger als 4 Zeichen -> Ungültig");
            } else {
                if (s.matches("[^0-9a-f]")) {
                    System.out.println(s + " Enthält ungültige Symbole -> Ungültig");
                } else {
                    System.out.println(s + " Enthält korrekte Symbole");
                }
            }
        }
    }
}

 

[Nooobi]

Verwende bitte die Codetags (das </> Symbol im Editor).

public class IPTEST {
    // Main Methode
    public static void main(String[] args) {
        String IPv6Screen1 = "fe80:f3x:ACBA:0000:2341:CCBA:A278:04B1";
        String IPv6Screen = IPv6Screen1.toLowerCase();
        // Aufrufen von Methoden
        Check(IPv6Screen);
    }
   
    // Methode zum Abfragen ob der IPv6 String gültig ist
    public static void Check(String IPv6Screen) {
        String split[] = IPv6Screen.split(":", 8);

        // Check in Schleife
        for (String s : split) {
            if (s.length() > 4) {
                System.out.println(s + " Ist länger als 4 Zeichen -> Ungültig");
            } else {
                if (s.matches("[^0-9a-f]")) {
                    System.out.println(s + " Enthält ungültige Symbole -> Ungültig");
                } else {
                    System.out.println(s + " Enthält korrekte Symbole");
                }
            }
        }
    }
}

Ups Ja, vielen dank. Ich habe es bearbeitet.

 

[KonradN]

String.matches prüft den ganzen String, also es entspricht unter dem Strich einem ^[^0-9a-f]$.

Du willst aber nicht prüfen, ob der ganze String dem Regulären Ausdruck entspricht sondern Du willst einfach nur wissen, ob so ein Element vorkommt. Also etwas wie .*([^0-9a-f])+.*.
Sprich: Es kann vorab beliebige Zeichen geben. Dann muss ein oder mehrere unzulässige Zeichen kommen und dann wieder beliebig viele andere Zeichen.

Edit: Die (...) kannst Du natürlich weg lassen. Das brauchst Du nur, wenn Du die ungültigen Zeichen über eine Gruppe auch haben möchtest. Ein .*[^0-9a-f]+.* reicht für deinen Code natürlich, da Du ja eh keinen Matcher hast.

 

[Nooobi]

String.matches prüft den ganzen String, also es entspricht unter dem Strich einem ^[^0-9a-f]$.

Du willst aber nicht prüfen, ob der ganze String dem Regulären Ausdruck entspricht sondern Du willst einfach nur wissen, ob so ein Element vorkommt. Also etwas wie .*([^0-9a-f])+.*.
Sprich: Es kann vorab beliebige Zeichen geben. Dann muss ein oder mehrere unzulässige Zeichen kommen und dann wieder beliebig viele andere Zeichen.

Edit: Die (...) kannst Du natürlich weg lassen. Das brauchst Du nur, wenn Du die ungültigen Zeichen über eine Gruppe auch haben möchtest. Ein .*[^0-9a-f]+.* reicht für deinen Code natürlich, da Du ja eh keinen Matcher hast.

Vielen Dank! So funktioniert das Jetzt gibt er mir das richtig aus.

 

[LimDul]

War Unfug

 

[KonradN]

War Unfug

Der Ansatz war durchaus auch ok. Du musst Dann nur auch das ^ entfernen. Du kannst also statt nach ungültigen Zeichen auch sicherstellen, dass nur gültige Zeichen da sind. Da kann man dann auch die Länge mit prüfen (wenn es genau 4 Ziffern sein müssen aber ggf. sind auch weniger ok?):

Also ein regulärer Ausdruck [0-9a-f]+ stelt sicher, dass nur gültige Zeichen vorhanden sind. Falls jemand das mit RegEx Implementationen nutzt, die nicht den ganzen String prüfen, kann man das noch sicher stellen: ^[0-9a-f]+$

Und wenn man die Länger sicherstellen will:
^[0-9a-f]{1,4}$ für eine Länge von 1 - 4. (Kann man auch auf 0 setzen - dann wäre der leere String auch ok.
^[0-9a-f]{4}$ für eine Länge von genau 4.

Natürlich ist dann noch wichtig: Das if ist jetzt umgedreht. true bedeutete bisher bei Dir: Ungültig. Jetzt bedeutet ein true: gültig.

 

[LimDul]

Der Ansatz war durchaus auch ok. Du musst Dann nur auch das ^ entfernen. Du kannst also statt nach ungültigen Zeichen auch sicherstellen, dass nur gültige Zeichen da sind. Da kann man dann auch die Länge mit prüfen (wenn es genau 4 Ziffern sein müssen aber ggf. sind auch weniger ok?):

Also ein regulärer Ausdruck [0-9a-f]+ stelt sicher, dass nur gültige Zeichen vorhanden sind. Falls jemand das mit RegEx Implementationen nutzt, die nicht den ganzen String prüfen, kann man das noch sicher stellen: ^[0-9a-f]+$

Und wenn man die Länger sicherstellen will:
^[0-9a-f]{1,4}$ für eine Länge von 1 - 4. (Kann man auch auf 0 setzen - dann wäre der leere String auch ok.
^[0-9a-f]{4}$ für eine Länge von genau 4.

Natürlich ist dann noch wichtig: Das if ist jetzt umgedreht. true bedeutete bisher bei Dir: Ungültig. Jetzt bedeutet ein true: gültig.

Jepp, aber da war ich jetzt parallel zur Telko nicht in der Lage das zu formulieren

 

[KonradN]

Das wäre sogar von der Vorgehensweise das, was ich bevorzugen würde. Zum einen ist es der positive Ansatz: Was ist erlaubt. Das ist in der Regel besser lesbar denn das wird in der Regel ja auch in Dokumentationen angegeben.

Und damit erspart man sich einige if / else in der Struktur.

Jepp, aber da war ich jetzt parallel zur Telko nicht in der Lage das zu formulieren

Das kenne ich etwas

 

[Jw456]

Tipp: bei verkürzte Schreibweise ist es da auch richtig?

2001 : 0000 : 0000 : 0000 : 0001 : 0000 : 0000 : 0001
verkürzt
2001 : : 1 : 0 : 0 : 1

 

[httpdigest]

Ja, die _gesamte_ valide Syntax von IPv6 Adressen abzubilden, erfordert seeeehr viel mehr Logik.
Siehe z.B.: https://stackoverflow.com/questions...-matches-valid-ipv6-addresses#answer-17871737
Seine Methode ist bisher: Wenn sie false zurückliefert, ist der übergebene String garantiert _keine_ gültige IPv6 Adresse.
Das heißt aber nicht: Wenn sie true zurückliefert, dass der übergebene String eine gültige IPv6 Adresse ist.