การแสดงออกปกติ Java

แสดงออกปกติกำหนดสตริงรูปแบบ

การแสดงออกปกติสามารถใช้ในการค้นหาแก้ไขหรือข้อความในการประมวลผล

การแสดงออกปกติไม่ จำกัด ภาษาบางอย่าง แต่มีความแตกต่างที่ลึกซึ้งในแต่ละภาษา

นิพจน์ทั่วไปของ Java และ Perl เป็นคล้ายกันมากที่สุด

แพคเกจ java.util.regex รวมถึงต่อไปสามประเภท:

• ประเภทรูปแบบ:

  รูปแบบวัตถุเป็นตัวแทนการแสดงออกของคอมไพเลอร์ปกติ ระดับแบบไม่เคยมีใครสร้างสาธารณะ การสร้างวัตถุรูปแบบที่คุณต้องเรียกวิธีการรวบรวมของสาธารณะคงที่ส่งกลับวัตถุรูปแบบ วิธีนี้ใช้เวลาการแสดงออกปกติเป็นอาร์กิวเมนต์แรกของ

• ประเภท Matcher:

  วัตถุ Matcher คือความหมายของสายป้อนและการดำเนินงานที่ตรงกับของเครื่องยนต์ เช่น class แบบที่ไม่เคยมีใคร Matcher สร้างสาธารณะ คุณจะต้องเรียกวัตถุวิธีการรูปแบบการจับคู่ที่จะได้รับวัตถุ Matcher

• PatternSyntaxException:

  PatternSyntaxException เป็นชั้นยกเว้นไม่ได้รับคำสั่งที่แสดงถึงข้อผิดพลาดของไวยากรณ์รูปแบบการแสดงออกปกติ

กลุ่มการบันทึก

กลุ่มการจับตัวละครหลายเมื่อมีวิธีการรักษาที่หน่วยเดียวผ่านตัวละครที่จัดกลุ่มในวงเล็บในการสร้าง

ยกตัวอย่างเช่นการแสดงออกปกติ (สุนัข) สร้างกลุ่มเดียวกลุ่มที่มี "D", "O" และ "G"

กลุ่มจับภาพโดยการคำนวณวงเล็บเปิดเลขจากซ้ายไปขวา ยกตัวอย่างเช่นในการแสดงออก ((A) (B (C))) มีสี่กลุ่มดังกล่าว:

• ((A) (B (C)))
• (A)
• (B (C))
• (C)

โดยการเรียกวิธีการจับคู่วัตถุ groupCount ที่จะเห็นการแสดงออกของแพ็คเก็ตหลายวิธี วิธี groupCount กลับ int เป็นตัวแทนของวัตถุที่จับคู่ในปัจจุบันมีกลุ่มจับหลาย

มีกลุ่มพิเศษ (กลุ่ม 0) ก็มักจะหมายถึงการแสดงออกทั้งหมด กลุ่มที่ไม่รวมอยู่ในค่าตอบแทน groupCount

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงวิธีการหาสตริงของตัวเลขจากสตริงได้รับ:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    public static void main( String args[] ){

      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // 创建 Pattern 对象
      Pattern r = Pattern.compile(pattern);

      // 现在创建 matcher 对象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
   }
}

ตัวอย่างข้างต้นรวบรวมผลมีดังนี้

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

ไวยากรณ์แสดงออกปกติ

วิธีการเรียน Matcher

วิธีการที่ดัชนี

วิธีการให้ดัชนีมีค่าดัชนีบ่งชี้ได้อย่างแม่นยำที่มีประโยชน์ที่จะหาตรงกับสายการป้อนข้อมูล:

ระเบียบวิธีวิจัย

วิธีการที่ใช้ในการตรวจสอบสายเข้าและส่งกลับค่าบูลีนแสดงให้เห็นหรือไม่ว่ารูปแบบที่พบ:

วิธีการเปลี่ยน

ทางเลือกคือการแทนที่สตริงในวิธีการป้อนข้อความ:

วิธีการเริ่มต้นและสิ้นสุด

นี่คือตัวอย่างของจำนวนของการเกิดขึ้นในสายป้อนสำหรับการนับคำว่า "แมว" ปรากฏนี้:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
                                    "cat cat cat cattie cat";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // 获取 matcher 对象
       int count = 0;

       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

ตัวอย่างข้างต้นรวบรวมผลมีดังนี้

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

นี้สามารถเห็นได้โดยใช้ขอบเขตตัวอย่างเช่นคำว่าเพื่อให้แน่ใจว่าตัวอักษร "C" "A" T "" ไม่ได้เป็นเพียงคำสตริงยาว นอกจากนี้ยังมีบางตำแหน่งข้อมูลที่เป็นประโยชน์เกี่ยวกับสายป้อนจะถูกจับคู่

วิธีการเริ่มต้นผลตอบแทนที่ได้ดำเนินการในระหว่างการแข่งขันก่อนหน้านี้จากเริ่มต้นดัชนีที่กำหนดกลุ่มจับ subsequence จบวิธีการจับคู่สุดท้ายดัชนีบวกตัวละครหนึ่ง

การแข่งขันและวิธีการ lookingAt

การแข่งขันและวิธีการ lookingAt จะใช้ในการพยายามให้ตรงกับลำดับของรูปแบบการป้อนข้อมูล พวกเขามีความแตกต่างจากความต้องการของการจับคู่จับคู่ลำดับทั้งหมด แต่ lookingAt ไม่จำเป็นต้องใช้

ทั้งสองวิธีมักจะใช้ในสายป้อนเริ่มต้น

ผ่านตัวอย่างต่อไปนี้จะอธิบายคุณลักษณะนี้:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);

       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
   }
}

ตัวอย่างข้างต้นรวบรวมผลมีดังนี้

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

วิธีการ replaceFirst และ replaceAll

replaceFirst และวิธี replaceAll ใช้ในการแทนที่ข้อความที่ตรงกับการแสดงออกปกติ ความแตกต่างคือ replaceFirst แทนที่นัดแรก replaceAll แทนที่การแข่งขันทั้งหมด

ตัวอย่างต่อไปนี้จะอธิบายคุณลักษณะนี้:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

ตัวอย่างข้างต้นรวบรวมผลมีดังนี้

The cat says meow. All cats say meow.

วิธีการ appendReplacement และ appendTail

ระดับ Matcher นอกจากนี้ยังมีวิธีการสำหรับการ appendTail appendReplacement และแทนที่ข้อความ:

ดูตัวอย่างต่อไปนี้จะอธิบายคุณลักษณะนี้:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

ตัวอย่างข้างต้นรวบรวมผลมีดังนี้

-foo-foo-foo-

วิธีการเรียน PatternSyntaxException

PatternSyntaxException เป็นชั้นยกเว้นไม่ได้รับคำสั่งซึ่งบ่งชี้ข้อผิดพลาดไวยากรณ์รูปแบบการแสดงออกปกติ

ระดับ PatternSyntaxException มีวิธีการดังต่อไปนี้เพื่อช่วยให้เรามองเห็นสิ่งที่เกิดข้อผิดพลาด