Ungkapan biasa Java


Ungkapan biasa mentakrifkan corak rentetan.

Ungkapan biasa boleh digunakan untuk mencari, mengedit atau memproses teks.

Ungkapan biasa tidak terhad kepada satu bahasa, tetapi terdapat perbezaan halus dalam setiap bahasa.

Ungkapan biasa Java paling serupa dengan Perl.

Pakej java.util.regex terutamanya termasuk tiga kelas berikut:

  • Kelas corak:

    objek corak ialah Perwakilan tersusun bagi ungkapan biasa. Kelas corak tidak mempunyai pembina awam. Untuk mencipta objek Corak, anda mesti terlebih dahulu memanggil kaedah kompilasi statik awamnya, yang mengembalikan objek Corak. Kaedah ini menerima ungkapan biasa sebagai parameter pertamanya.

  • Kelas matcher:

    Objek Matcher ialah enjin yang mentafsir dan memadankan rentetan input. Seperti kelas Pattern, Matcher tidak mempunyai pembina awam. Anda perlu memanggil kaedah pemadan bagi objek Corak untuk mendapatkan objek Pencocokan.

  • PatternSyntaxException:

    PatternSyntaxException ialah kelas pengecualian bukan mandatori yang mewakili ralat sintaks dalam corak ungkapan biasa.

Kumpulan tangkapan

Kumpulan tangkapan ialah kaedah untuk merawat berbilang aksara sebagai satu unit Ia dicipta dengan mengumpulkan aksara dalam kurungan.

Sebagai contoh, ungkapan biasa (anjing) mencipta satu kumpulan yang mengandungi "d", "o" dan "g".

Kumpulan penangkapan dinomborkan dengan mengira kurungan pembukaan mereka dari kiri ke kanan. Sebagai contoh, dalam ungkapan ((A)(B(C))), terdapat empat kumpulan sedemikian:

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

  • (A)

  • (B(C))

  • (C)

Anda boleh menyemak bilangan kumpulan yang ada pada ungkapan dengan memanggil kaedah groupCount objek pemadan. Kaedah groupCount mengembalikan nilai int, menunjukkan bahawa objek pemadan pada masa ini mempunyai berbilang kumpulan penangkapan.

Terdapat juga kumpulan khas (kumpulan 0) yang sentiasa mewakili keseluruhan ungkapan. Kumpulan tidak termasuk dalam nilai pulangan groupCount.

Contoh

Contoh berikut menunjukkan cara mencari rentetan nombor daripada rentetan yang diberikan: 

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");
      }
   }
}

Contoh di atas menyusun dan menjalankan hasilnya seperti berikut: 

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

Sintaks ungkapan biasa

$

Watak

Penerangan

Tandakan aksara seterusnya sebagai aksara khas, teks, rujukan belakang atau pelarian oktal. Contohnya, "n" sepadan dengan aksara "n". "n" sepadan dengan aksara baris baharu. Urutan "\" sepadan dengan "", "(" sepadan dengan "(".

^

sepadan dengan aksara input Kedudukan di mana rentetan bermula. Jika atribut Multiline objek RegExp ditetapkan, ^ juga akan sepadan dengan kedudukan selepas "n" atau "r". >

sepadan dengan penghujung rentetan input. Jika sifat Multiline bagi objek RegExp ditetapkan, $ juga akan sepadan dengan kedudukan sebelum "n" atau "r".

*

sepadan dengan aksara atau subungkapan sebelumnya sifar atau lebih kali. Contohnya, zo* sepadan dengan "z" dan "zoo". * Bersamaan dengan {0,}.

+

sepadan dengan aksara atau subungkapan sebelumnya satu kali atau lebih. Contohnya, "zo+" sepadan dengan "zo" dan "zoo" tetapi bukan "z". + Bersamaan dengan {1,}.

?

sepadan dengan aksara atau subungkapan sebelumnya sifar atau sekali. Contohnya, "do(es)?" sepadan dengan "do" atau "do" dalam "does". ? Bersamaan dengan {0,1}.

{n}

n ialah bukan- integer negatif. Padan tepat n kali. Contohnya, "o{2}" tidak sepadan dengan "o" dalam "Bob", tetapi sepadan dengan kedua-dua "o" dalam "makanan".

{n,}

n ialah bukan -integer negatif . Padankan sekurang-kurangnya n kali. Contohnya, "o{2,}" tidak sepadan dengan "o" dalam "Bob" tetapi sepadan dengan semua o dalam "foooood". "o{1,}" bersamaan dengan "o+". "o{0,}" bersamaan dengan "o*".

{n,m}

M dan n ialah integer bukan negatif, dengan n <= m. Padankan sekurang-kurangnya n kali dan paling banyak m kali. Contohnya, "o{1,3}" sepadan dengan tiga o pertama dalam "fooooood". 'o{0,1}' bersamaan dengan 'o?'. Nota: Anda tidak boleh memasukkan ruang antara koma dan nombor.

?

Apabila watak ini diikuti oleh mana-mana pelayakkan lain (*, +, ?, {n}, {n,}, {n,m}), corak padanan ialah "tidak tamak". Corak "tidak tamak" sepadan dengan rentetan terpendek yang mungkin dicari, manakala corak lalai "tamak" sepadan dengan rentetan terpanjang yang mungkin dicari. Contohnya, dalam rentetan "oooo", "o+?" hanya sepadan dengan "o" tunggal, manakala "o+" sepadan dengan semua "o".

.

sepadan dengan mana-mana aksara tunggal kecuali "rn". Untuk memadankan mana-mana aksara termasuk "rn", gunakan corak seperti "[sS]".

(corak)

sepadan dengan corak dan menangkapnya Subungkapan yang sepadan. Padanan yang ditangkap boleh diambil daripada koleksi "perlawanan" yang dihasilkan menggunakan atribut $0…$9. Untuk memadankan aksara kurungan ( ), gunakan "(" atau ")".

(?:corak)

sepadan dengan corak tetapi tidak menangkap subungkapan perlawanan itu, iaitu perlawanan bukan menangkap dan tidak menyimpan perlawanan untuk kegunaan kemudian. Ini berguna apabila menggabungkan bahagian corak dengan aksara "atau" (|). Sebagai contoh, 'industr(?:y|ies) ialah ungkapan yang lebih menjimatkan daripada 'industri|industries'.

(?=corak)

Subungkapan yang melakukan carian pandang ke hadapan Ungkapan yang sepadan dengan rentetan pada permulaan rentetan padanan corak. Ia adalah perlawanan bukan penangkapan, iaitu perlawanan yang tidak boleh ditangkap untuk kegunaan kemudian. Contohnya, 'Windows (?=95|98|NT|2000)' sepadan dengan "Windows" dalam "Windows 2000" tetapi bukan "Windows" dalam "Windows 3.1". Pandangan ramalan tidak menduduki aksara, iaitu, selepas perlawanan berlaku, perlawanan seterusnya dicari sejurus selepas perlawanan sebelumnya, bukan selepas watak yang membentuk pandangan ramalan.

(?!corak)

Sub-ungkapan yang melakukan pandangan songsang ke hadapan carian Ungkapan yang sepadan dengan rentetan carian yang bukan pada permulaan rentetan yang sepadan dengan corak. Ia adalah perlawanan bukan penangkapan, iaitu perlawanan yang tidak boleh ditangkap untuk kegunaan kemudian. Contohnya, 'Windows (?!95|98|NT|2000)' sepadan dengan "Windows" dalam "Windows 3.1" tetapi bukan "Windows" dalam "Windows 2000". Pandangan ramalan tidak menduduki aksara, iaitu, selepas perlawanan berlaku, perlawanan seterusnya dicari sejurus selepas perlawanan sebelumnya, bukan selepas watak yang membentuk pandangan ramalan.

x|y

sepadan dengan x atau y. Contohnya, 'z|makanan' sepadan dengan "z" atau "makanan". '(z|f)ood' sepadan dengan "zood" atau "makanan".

[xyz]

set watak. Padan dengan mana-mana aksara yang terkandung dalam . Contohnya, "[abc]" sepadan dengan "a" dalam "plain".

[^xyz]

Set aksara songsang. Padan dengan mana-mana aksara yang tidak disertakan. Contohnya, "[^abc]" sepadan dengan "p", "l", "i" dan "n" dalam "plain".

[a-z]

julat aksara. Memadankan mana-mana aksara dalam julat yang ditentukan. Contohnya, "[a-z]" sepadan dengan mana-mana huruf kecil dalam julat "a" hingga "z".

[^a-z]

Watak julat songsang. Padan dengan mana-mana aksara yang tidak dalam julat yang ditentukan. Contohnya, "[^a-z]" sepadan dengan mana-mana aksara yang tidak berada dalam julat "a" hingga "z".

b

sepadan dengan sempadan perkataan, iaitu kedudukan antara perkataan dan ruang. Sebagai contoh, "erb" sepadan dengan "er" dalam "tidak pernah", tetapi bukan "er" dalam "kata kerja".

B

padanan sempadan bukan perkataan. "erB" sepadan dengan "er" dalam "kata kerja", tetapi bukan "er" dalam "tidak pernah".

cx

sepadan dengan aksara kawalan yang ditunjukkan oleh x. Contohnya, cM sepadan dengan Control-M atau carriage return. Nilai x mestilah antara A-Z atau a-z. Jika ini tidak berlaku, c diandaikan sebagai watak "c" itu sendiri.

d

Padanan aksara nombor. Bersamaan dengan [0-9].

D

padanan aksara bukan angka. Bersamaan dengan [^0-9].

f

padanan suapan borang. Bersamaan dengan x0c dan cL.

n

padanan baris baharu. Bersamaan dengan x0a dan cJ.

r

sepadan dengan watak carriage return. Bersamaan dengan x0d dan cM.

s

sepadan dengan mana-mana aksara ruang putih, termasuk ruang, tab, suapan borang, dsb. Bersamaan dengan [ fnrtv].

S

sepadan dengan mana-mana aksara bukan ruang putih. Bersamaan dengan [^ fnrtv].

t

padanan tab. Bersamaan dengan x09 dan cI.

v

pemadanan tab menegak. Bersamaan dengan x0b dan cK.

w

sepadan dengan mana-mana aksara jenis perkataan, termasuk garis bawah. Bersamaan dengan "[A-Za-z0-9_]".

W

sepadan dengan mana-mana aksara bukan perkataan. Bersamaan dengan "[^A-Za-z0-9_]".

xn

sepadan dengan n, di mana n ialah kod pelarian heksadesimal. Kod pelarian heksadesimal mestilah tepat dua digit panjangnya. Contohnya, "x41" sepadan dengan "A". "x041" bersamaan dengan "x04"&"1". Benarkan kod ASCII dalam ungkapan biasa.

num

sepadan dengan num, di mana num ialah integer positif. Rujukan belakang untuk menangkap perlawanan. Contohnya, "(.)1" sepadan dengan dua aksara yang serupa berturut-turut.

n

Mengenal pasti kod pelarian oktal atau rujukan belakang. Jika n didahului dengan sekurang-kurangnya n menangkap subungkapan, maka n ialah rujukan belakang. Jika tidak, jika n ialah nombor perlapanan (0-7), maka n ialah kod pelarian oktal.

nm

Mengenal pasti kod pelarian oktal atau rujukan belakang. Jika nm didahului dengan sekurang-kurangnya nm menangkap subungkapan, maka nm ialah rujukan belakang. Jika nm didahului dengan sekurang-kurangnya n tangkapan, maka n ialah rujukan belakang diikuti oleh aksara m. Jika kedua-dua keadaan sebelumnya tidak wujud, maka nm sepadan dengan nilai perlapanan nm, dengan n dan m ialah digit perlapanan (0 - 7).

nml

Apabila n ialah nombor perlapanan ( 0 -3), apabila m dan l ialah nombor perlapanan (0-7), padankan kod pelarian perlapanan nml.

un

sepadan dengan n, dengan n ialah aksara Unicode yang diwakili sebagai nombor perenambelasan empat digit. Contohnya, u00A9 sepadan dengan simbol hak cipta (©).

Kaedah kelas Matcher

Kaedah indeks

Kaedah indeks menyediakan nilai indeks berguna yang menunjukkan input dengan tepat rentetan Di mana untuk mencari padanan:

Nombor siri< / th>Kaedah dan arahan
序号方法及说明
                    1public int start()
返回以前匹配的初始索引。
                    2public int start(int group)
 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
                    3public int end()
返回最后匹配字符之后的偏移量。
                    4public int end(int group)
返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
1

public int start()
Mengembalikan indeks awal perlawanan sebelumnya.

2

permulaan int awam(kumpulan int)
Mengembalikan indeks awal urutan yang ditangkap oleh kumpulan yang diberikan semasa operasi pemadanan sebelumnya
序号方法及说明
                    1public boolean lookingAt()
 尝试将从区域开头开始的输入序列与该模式匹配。
                    2public boolean find()
尝试查找与该模式匹配的输入序列的下一个子序列。
                    3public boolean find(int start）
重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
                    4public boolean matches()
尝试将整个区域与模式匹配。
<🎜> 3<🎜>public int end()
Mengembalikan offset selepas aksara padanan terakhir. <🎜><🎜> 4<🎜>penghujung int awam(kumpulan int)
Mengembalikan offset selepas aksara terakhir bagi urutan yang ditangkap oleh kumpulan yang diberikan semasa operasi pemadanan sebelumnya. <🎜><🎜><🎜><🎜><🎜>Kaedah penyelidikan<🎜><🎜>Kaedah penyelidikan digunakan untuk menyemak rentetan input dan mengembalikan nilai Boolean yang menunjukkan sama ada corak ditemui: <🎜>Nombor siri< strong>Kaedah dan arahan<🎜> 1<🎜>public boolean lookingAt()
Percubaan untuk memadankan jujukan input bermula dari permulaan rantau hingga corak ini. <🎜><🎜> 2<🎜>public boolean find()
Cuba cari urutan seterusnya bagi urutan input yang sepadan dengan corak ini. <🎜><🎜> 3<🎜>public boolean find(int start)
Menetapkan semula padanan ini dan cuba mencari urutan seterusnya bagi jujukan input bermula pada indeks yang ditentukan yang sepadan dengan corak. <🎜><🎜> 4<🎜>padanan boolean awam()
Cuba padankan keseluruhan kawasan dengan corak. <🎜><🎜><🎜><🎜>

Kaedah penggantian

Kaedah penggantian adalah untuk menggantikan teks dalam rentetan input:

序号方法及说明
                    1public Matcher appendReplacement(StringBuffer sb, String replacement)
实现非终端添加和替换步骤。
                    2public StringBuffer appendTail(StringBuffer sb)
实现终端添加和替换步骤。
                    3public String replaceAll(String replacement)
 替换模式与给定替换字符串相匹配的输入序列的每个子序列。
                    4public String replaceFirst(String replacement)
 替换模式与给定替换字符串匹配的输入序列的第一个子序列。
                    5public static String quoteReplacement(String s)
返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。

kaedah mula dan tamat

Berikut ialah contoh mengira bilangan kali perkataan "kucing" muncul dalam rentetan input: 

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());
      }
   }
}

Hasil penyusunan dan larian di atas contohnya adalah seperti berikut: 

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

Anda boleh melihat bahawa contoh ini menggunakan sempadan perkataan untuk memastikan bahawa huruf "c" "a" "t" bukan sekadar subrentetan perkataan yang lebih panjang. Ia juga menyediakan beberapa maklumat berguna tentang tempat dalam rentetan input padanan itu berlaku.

Kaedah Mula mengembalikan indeks awal urutan yang ditangkap oleh kumpulan yang diberikan semasa operasi pemadanan sebelumnya, dan kaedah penamat menambah satu pada indeks aksara dipadankan terakhir.

kaedah padanan dan lookingAt

Kaedah padanan dan lookingAt digunakan untuk cuba memadankan corak jujukan input. Perbezaan di antara mereka ialah matcher memerlukan keseluruhan urutan untuk dipadankan, manakala lookingAt tidak.

Kedua-dua kaedah ini sering digunakan pada permulaan rentetan input.

Kami menggunakan contoh berikut untuk menerangkan fungsi ini: 

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());
   }
}

Hasil penyusunan dan jalankan contoh di atas adalah seperti berikut: 

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

replaceFirst dan replaceAll kaedah

replaceFirst dan Kaedah replaceAll digunakan untuk menggantikan teks yang sepadan dengan ungkapan biasa. Perbezaannya ialah replaceFirst menggantikan perlawanan pertama dan replaceAll menggantikan semua perlawanan.

Contoh berikut menerangkan fungsi ini: 

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);
   }
}

Hasil penyusunan dan jalankan contoh di atas adalah seperti berikut: 

The cat says meow. All cats say meow.

appendReplacement dan kaedah appendTail

Kelas Matcher juga menyediakan Kaedah appendReplacement dan appendTail digunakan untuk penggantian teks:

Lihat contoh berikut untuk menerangkan fungsi ini: 

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());
   }
}

Hasil penyusunan dan jalankan contoh di atas adalah seperti berikut: 

-foo-foo-foo-

Kaedah kelas PatternSyntaxException

PatternSyntaxException ialah kelas pengecualian tidak paksa yang menunjukkan ralat sintaks dalam corak ungkapan biasa.

Kelas PatternSyntaxException menyediakan kaedah berikut untuk membantu kami melihat ralat yang berlaku.

序号方法及说明
                    1public String getDescription()
获取错误的描述。
                    2public int getIndex()
 获取错误的索引。
                    3public String getPattern()
获取错误的正则表达式模式。
                    4public String getMessage()
返回多行字符串，包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示。