[Java] Zusammenfassung der regulären Ausdrücke

Aufführen

Übereinstimmendes Beispiel für Telefon- / Postleitzahl

//Beispiel 1 Telefon/Postleitzahl übereinstimmen
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
 public static void main(String[] args) {
    //Zu beurteilende Zeichenkette
    String str = "012-345-6789";
    //Generieren Sie ein zu beurteilendes Muster
    Pattern p = Pattern.compile("\\d{2,4}-\\d{2,4}-\\d{4}"); //Telefonnummer
    //Pattern p = Pattern.compile("^\\d{3}-\\d{4}$"); //Postleitzahl
    Matcher m = p.matcher(str);

    System.out.println(m.find()); //true
    }
}

Vorwärts- / Rückwärts- / Teilübereinstimmungsprobe

//Probe 2 vorwärts/Rückseite/Teilweise Übereinstimmung
public class Main {
 public static void main(String[] args) {
    //Zu beurteilende Zeichenkette
    String str = "000012-345-6789";
    //Generieren Sie ein zu beurteilendes Muster
    //Pattern p = Pattern.compile("\\d{2,4}-\\d{2,4}-\\d{4}.*"); //Präfix der Telefonnummer
    //Pattern p = Pattern.compile(".*\\d{2,4}-\\d{2,4}-\\d{4}"); //Telefonnummer Suffix übereinstimmen
    Pattern p = Pattern.compile(".*\\d{2,4}-\\d{2,4}-\\d{4}.*"); //Teilweise Übereinstimmung der Telefonnummer
    Matcher m = p.matcher(str);

    System.out.println(m.find()); //true
    }
}

Extrahieren Sie die übereinstimmende Zeichenfolge

• Bereiten Sie das Pattern-Objekt mit der Kompilierungsmethode der Pattern-Klasse vor
• Erstellen Sie ein Macher-Objekt, das mithilfe der Matcher-Methode nach einer Zeichenfolge sucht
• Wiederholen Sie den Abgleich mit "while (match.find ())", bis die Suchmethode falsch wird, und ermitteln Sie die Startposition (Start), die Endposition (Ende) und die Übereinstimmungszeichenfolge (Gruppe) der Zeichenfolge.
• group [0]: gesamte übereinstimmende Zeichenfolge
• group [1]: Erstes Element der Submatch-Zeichenfolge

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Mobil ist 0123-99-Es ist 0000. Zuhause ist 000-123-4567 und so weiter.";
    var ptn = Pattern.compile("(\\d{2,4})-(\\d{2,4})-(\\d{4})");
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println("Startposition:" + match.start());
      System.out.println("Endposition:" + match.end());
      System.out.println("Passende Zeichenfolge:" + match.group());
      System.out.println("Vorwahl:" + match.group(1));
      System.out.println("Postleitzahl:" + match.group(2));
      System.out.println("Abonnentenanzahl:" + match.group(3));
      System.out.println("-----");
    }
  }
}

Verhaltenskontrolle während des Matchings

• Sie können das Verhalten ändern, wenn Sie die Pattern-Klasse mit dem Match-Flag instanziieren.

CASE_INSENSITIVE

• Groß- und Kleinschreibung wird nicht berücksichtigt

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Für die Arbeit ist [email protected] ist com. NEKO für den privaten [email protected] ist com.";
    var ptn = Pattern.compile("[a-z0-9.!#$%&'*+/=?^_{|}~-]+@[a-z0-9-]+(\\.[a-z0-9-]+)*", Pattern.CASE_INSENSITIVE);
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println(match.group());
    }
  }
}

MULTILINE

• Ändern Sie das Verhalten von ^ und $
• ^ entspricht nicht nur dem Anfang, sondern auch der Zahl nach dem Zeilenumbruch
• Im Fall von "$" stimmt es auch mit dem Zeilenende überein

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Freunde in der ersten Klasse\Ich frage mich, ob n100 Leute das können\n";
    // var ptn = Pattern.compile("^\\d*");
    var ptn = Pattern.compile("^\\d*", Pattern.MULTILINE);
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println(match.group()); //1 100
    }
  }
}

DOTALL

• Ändere das Verhalten von .
• Entspricht allen Zeichenfolgen einschließlich Zeilenumbrüchen (\ n)
• Zeichenketten können als einzelne Zeile abgeglichen werden (einzeiliger Modus)

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Wollte sich treffen\nWollte sich treffen\nWollte sich treffen\nYES";
    // var ptn = Pattern.compile("^.+");
    var ptn = Pattern.compile("^.+", Pattern.DOTALL);
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println(match.group());
      //Wollte sich treffen
      //Wollte sich treffen
      //Wollte sich treffen
      //YES
    }
  }
}

Eingebettete Flagge

• Der folgende Code ist der gleiche
  • ?i ：CASE_INSENSITIVE
  • ?m ：MULTILINE
  • ?s ：DOTALL
  • ?u ：UNICODE_CASE
  • ?d ：UNIX_LINES
  • ?x ：COMMENTS

var ptn = Pattern.compile("(?i)[a-z0-9.!#$%&'*+/=?^_{|}~-]+@[a-z0-9-]+(\\.[a-z0-9-]+)*");

//var ptn = Pattern.compile("[a-z0-9.!#$%&'*+/=?^_{|}~-]+@[a-z0-9-]+(\\.[a-z0-9-]+)*", Pattern.CASE_INSENSITIVE);

Längste Übereinstimmung / kürzeste Übereinstimmung

• ** <. +> ** Längste Übereinstimmung (Übereinstimmung mit einer möglichst langen Zeichenfolge)
• In <...>. (Beliebiges Zeichen) ist + (1 oder mehr Zeichen)
• Alle Tag-Zeichen werden ausgegeben
• ** <. +?> ** Kürzeste Übereinstimmung (Übereinstimmung mit einer möglichst kurzen Zeichenfolge)
• Geben Sie jedes Tag-Zeichen einzeln aus

import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var tags = "<p><strong>NEKO</strong>Seite? ˅<a href='index.html'><img src='cat.jpg' /></a></p>";
    //Längste Übereinstimmung
    //var ptn = Pattern.compile("<.+>"); //<p><strong>NEKO</strong>Seite? ˅<a href='index.html'><img src='cat.jpg' /></a></p>
    //Kürzeste Übereinstimmung
    var ptn = Pattern.compile("<.+?>");
    var match = ptn.matcher(tags);
    while (match.find()) {
      System.out.println(match.group());
      //<p>
      //<strong>
      //</strong>
      //<a href='index.html'>
      //<img src='cat.jpg' />
      //</a>
      //</p>
    }
  }
}

Benannter Capture

• Name und Erfassungsgruppe
• Zugriff mit group (" name ")

import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var msg = "Mobil ist 0123-99-Es ist 0000. Zuhause ist 000-123-4567 und so weiter.";
    var ptn = Pattern.compile("(?<area>\\d{2,4})-(?<city>\\d{2,4})-(?<local>\\d{4})");
    var match = ptn.matcher(msg);
    while (match.find()) {
      System.out.println("Startposition:" + match.start());
      System.out.println("Endposition:" + match.end());
      System.out.println("Passende Zeichenfolge:" + match.group());
      System.out.println("Vorwahl:" + match.group("area"));
      System.out.println("Postleitzahl:" + match.group("city"));
      System.out.println("Abonnentenanzahl:" + match.group("local"));
      System.out.println("-----");
    }
  }
}

Rückverweis

• Übereinstimmende Zeichenfolgen können später mit "\ 1" referenziert werden

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {
  //Rückverweis
  public static void main(String args[]){
    String str1 = "My name is <div>Neko</div>";
    String str2 = "I am a <span>Cat</span>";
    String str3 = "<span>Hello World</div>";
    String regex = "<(div|span)>.*?<\\/\\1>";
    Pattern p = Pattern.compile(regex);
    System.out.println("Muster: " + regex);
    check(p, str1);
    check(p, str2);
    check(p, str3);
  }
  private static void check(Pattern p, String target){
    Matcher m = p.matcher(target);

    if (m.find()){
      System.out.println("Match! " + target);
    }else{
      System.out.println("Unmatch! " + target);
    }
  }
}

Vorausschau / Vorausschau

• Beurteilen Sie, ob es mit dem Vorhandensein oder Fehlen der vorhergehenden und folgenden Zeichenketten übereinstimmt
• ** A (? = B) **: Entspricht A nur, wenn B A folgt
• ** A (?! B) **: Entspricht A nur, wenn B nicht unmittelbar auf A folgt
• ** (? <= B) A **: Entspricht A nur, wenn unmittelbar vor A B steht
• ** (? <! B) A **: Entspricht A nur, wenn unmittelbar vor A kein B steht

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {

  private static void match(Pattern ptn, String input) {
    var match = ptn.matcher(input);
    while (match.find()) {
      System.out.println(match.group());
    }
    System.out.println("---");
  }

  public static void main(String[] args) {
    var re1 = Pattern.compile("Meine(?=Ja)"); 
    var re2 = Pattern.compile("Meine(?!Ja)"); 
    var re3 = Pattern.compile("(?<=。)Meine");  
    var re4 = Pattern.compile("(?<!。)Meine"); 
    var msg1 = "Mein Ja ist eine Katze";        
    var msg2 = "Ich bin eine Katze. Mein Name ist noch nicht da.";
    match(re1, msg1); //Meine
    match(re1, msg2); //---
    match(re2, msg1); //---
    match(re2, msg2); //Meine,Meine,Meine
    match(re3, msg1); //---
    match(re3, msg2); //Meine
    match(re4, msg1); //Meine
    match(re4, msg2); //Meine,Meine
  }
}

String-Ersatz

• ** replaceAll-Methode **
• Die Zeichenfolge nach dem Ersetzen kann die Zeichenfolge vor dem Ersetzen enthalten
• $ 0 gesamte Übereinstimmungszeichenfolge
• $ 1 Submatch-Zeichenfolge zuerst
• Benannte Kapitelgruppen verfügbar mit $ {" name "}
• ** replaceFirst-Methode **: Ersetzen Sie nur die erste Zeichenfolge
• • ** Methode ersetzen **: Feste Zeichenfolge ersetzen

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {

  public static void main(String[] args) {
    var str = "Klicken Sie hier für Anfragen https://www.neko.com/ist.";
    System.out.println(str.replaceAll(
        "(?i)http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\\\w ./?%&=-]*)?",
        "<a href=\"$0\">$0</a>"));
     //Kontaktiere uns<a href="https://www.neko.com/">https://www.neko.com/</a>ist.
  }
}

String split

• ** Split-Methode **
• cf: Die Aufteilung der strig-Klasse kompiliert jedes Mal den regulären Ausdruck
• Verwenden Sie die Pattern-Klasse, wenn Sie dasselbe Pattern wiederverwenden

import java.util.regex.Pattern;
public class Main {
  //Eine oder mehrere Ziffern+Teilen mit
  public static void main(String[] args) {
    var str = "Es gibt 2 Krokodile und 22 Krokodile";
    var re = Pattern.compile("\\d{1,}Beeindruckend");
    var result = re.split(str);
    System.out.println(String.join(" ", result)); 
    //Hinten ist ein Eichhörnchen
  }
}