Mga Regular na Ekspresyon sa Java, Bahagi 1

Dinadala namin sa iyong pansin ang pagsasalin ng isang maikling gabay sa mga regular na expression sa wikang Java, na isinulat ni Jeff Friesen para sa website ng JavaWorld . Para sa kadalian ng pagbabasa, hinati namin ang artikulo sa ilang bahagi.

Paggamit ng Regular Expression API sa Java Programs para Kilalanin at Ilarawan ang mga Pattern

Ang character ng Java at iba't ibang uri ng data ng string ay nagbibigay ng mababang antas ng suporta para sa pagtutugma ng pattern, ngunit ang paggamit sa mga ito para sa layuning ito ay karaniwang nagdaragdag ng makabuluhang pagiging kumplikado ng code. Nakukuha ang mas simple at mas gumaganang code sa pamamagitan ng paggamit ng Regex API ("Regular Expression API"). Tutulungan ka ng tutorial na ito na makapagsimula sa mga regular na expression at Regex API. Tatalakayin muna natin ang tatlong pinakakawili-wiling klase sa package sa pangkalahatan java.util.regex, at pagkatapos ay tingnan ang loob ng klase Patternat tuklasin ang mga sopistikadong pattern-matching construct nito. Pansin: Maaari mong i-download ang source code (nilikha ni Jeff Friesen para sa JavaWorld site) ng demo application mula sa artikulong ito mula dito .

Ano ang mga regular na expression?

Ang isang regular na expression (regular expression/regex/regexp) ay isang string na isang pattern na naglalarawan sa isang tiyak na hanay ng mga string. Tinutukoy ng pattern kung aling mga row ang nabibilang sa set. Ang pattern ay binubuo ng mga literal at metacharacter—mga character na may espesyal na kahulugan sa halip na literal na kahulugan. Ang paghahanap ng pattern ay isang paghahanap sa pamamagitan ng teksto upang makahanap ng mga tugma, iyon ay, mga string na tumutugma sa isang regular na pattern ng expression. Sinusuportahan ng Java ang pagtutugma ng pattern sa pamamagitan ng Regex API nito. Ang API na ito ay binubuo ng tatlong klase: Pattern, Matcherat PatternSyntaxException, na matatagpuan sa package java.util.regex:

• class objects Pattern, tinatawag ding templates, ay pinagsama-samang mga regular na expression.
• class objects Matcher, o matchers, ay mga mekanismo ng interpretasyon ng pattern para sa paghahanap ng mga tugma sa mga pagkakasunud-sunod ng character (mga bagay na ang mga klase ay nagpapatupad ng interface java.lang.CharSequenceat nagsisilbing text source).
• PatternSyntaxExceptionGinagamit ang mga bagay ng klase upang ilarawan ang mga di-wastong pattern ng regular na expression.

Nagbibigay din ang Java ng suporta para sa pagtutugma ng pattern sa pamamagitan ng iba't ibang pamamaraan ng java.lang.String. Halimbawa, boolean matches (String regex)babalik truelamang ang function kung eksaktong tumutugma ang string ng pagtawag sa regular na expression regex.

RegexDemo

Gumawa ako ng isang application RegexDemoupang ipakita ang mga regular na expression ng Java at iba't ibang pamamaraan ng Pattern, Matcherat PatternSyntaxException. Nasa ibaba ang source code para sa demo application na ito. Listahan 1. Pagpapakita ng regular na ekspresyon

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
public class RegexDemo
{
   public static void main(String[] args)
   {
      if (args.length != 2)
      {
         System.err.println("usage: java RegexDemo regex input");
         return;
      }
      // Преобразуем символьные последовательности начала новой строки (\n) в символы начала строки.
      args[1] = args[1].replaceAll("\\\\n", "\n");
      try
      {
         System.out.println("regex = " + args[0]);
         System.out.println("input = " + args[1]);
         Pattern p = Pattern.compile(args[0]);
         Matcher m = p.matcher(args[1]);
         while (m.find())
            System.out.println("Found [" + m.group() + "] starting at "
                               + m.start() + " and ending at " + (m.end() - 1));
      }
      catch (PatternSyntaxException pse)
      {
         System.err.println("Неправильное регулярное выражение: " + pse.getMessage());
         System.err.println("Описание: " + pse.getDescription());
         System.err.println("Позиция: " + pse.getIndex());
         System.err.println("Неправильный шаблон: " + pse.getPattern());
      }
   }
}

Ang unang bagay na ginagawa ng isang paraan mainng klase RegexDemoay suriin ang command line nito. Nangangailangan ito ng dalawang argumento: ang una ay isang regular na expression, at ang pangalawa ay ang input text kung saan hahanapin ang regular na expression. Maaaring kailanganin mong gumamit ng newline na character sa loob ng input text (\n). Magagawa lamang ito sa pamamagitan ng pagtukoy ng karakter \na sinusundan ng karakter n. Kino-convert ng function main()ang sequence ng character na ito sa Unicode value 10. Ang karamihan ng code RegexDemoay nakapaloob sa try-catch. Ang block tryay unang naglalabas ng ibinigay na regular na expression at ang input text, at pagkatapos ay lumilikha ng isang bagay Patternna nag-iimbak ng pinagsama-samang regular na expression (ang mga regular na expression ay pinagsama-sama upang mapabuti ang pagganap ng pagtutugma ng pattern). Kinukuha ang isang matcher mula sa object Patternat ginagamit upang maghanap ng mga tugma nang paulit-ulit hanggang matagpuan ang lahat. Ang block catchay tumatawag ng ilang mga pamamaraan ng klase PatternSyntaxExceptionupang makuha ang kapaki-pakinabang na impormasyon tungkol sa pagbubukod. Ang impormasyong ito ay sunud-sunod na output sa output stream. Hindi na kailangang malaman ang mga detalye kung paano gumagana ang code: magiging malinaw ang mga ito kapag pinag-aralan natin ang API sa ikalawang bahagi ng artikulo. Gayunpaman, dapat mong i-compile ang Listahan 1. Kunin ang code mula sa Listahan 1, at pagkatapos ay i-type ang sumusunod na command sa command prompt upang i-compile RegexDemo: javac RegexDemo.java

Ang klase ng Pattern at mga konstruksyon nito

Ang klase Pattern, ang una sa tatlong klase na bumubuo sa Regex API, ay isang pinagsama-samang representasyon ng isang regular na expression. Ang dokumentasyon ng class SDK Patternay naglalarawan ng iba't ibang mga regular na expression construct, ngunit kung hindi ka aktibong gumagamit ng mga regular na expression, ang mga bahagi ng dokumentasyong ito ay maaaring nakakalito. Ano ang mga quantifier at ano ang pagkakaiba ng matakaw, atubili at possessive na quantifier? Ano ang mga klase ng character, boundary matcher, back reference, at naka-embed na flag expression? Sasagutin ko ito at ang iba pang mga tanong sa mga sumusunod na seksyon.

Mga literal na string

Ang pinakasimpleng pagbuo ng regular na expression ay isang literal na string. Para maging matagumpay ang pagtutugma ng pattern, dapat tumugma ang ilang bahagi ng input text sa pattern ng construct na iyon. Isaalang-alang ang sumusunod na halimbawa: java RegexDemo apple applet Sa halimbawang ito, sinusubukan naming maghanap ng tugma para sa isang pattern applesa input text applet. Ang sumusunod na resulta ay nagpapakita ng tugma na natagpuan:

regex = apple
input = applet
Found [apple] starting at 0 and ending at 4

Nakikita natin sa output ang regular na expression at ang input text, at pagkatapos ay isang indikasyon ng matagumpay na pagtuklas applesa applet. Bilang karagdagan, ang panimulang posisyon at pagtatapos ng laban na ito ay ibinibigay: 0at 4, ayon sa pagkakabanggit. Isinasaad ng panimulang posisyon ang unang lugar sa teksto kung saan natagpuan ang isang tugma, at ang posisyon ng pagtatapos ay nagpapahiwatig ng huling punto ng tugma. Ngayon sabihin natin na ibinigay namin ang sumusunod na command line: java RegexDemo apple crabapple Sa pagkakataong ito makuha namin ang sumusunod na resulta, na may iba't ibang panimulang posisyon at pagtatapos:

regex = apple
input = crabapple
Found [apple] starting at 4 and ending at 8

Kung hindi, kasama at appletbilang regular na expression apple- ang input text, walang makikitang mga tugma. Ang buong regular na expression ay dapat tumugma, ngunit sa kasong ito, ang input text ay hindi naglalaman tpagkatapos ng apple.

Mga Metacharacter

Pinagsasama ng mas kawili-wiling mga regular na expression ang mga literal na character sa metacharacter. Halimbawa, sa isang regular na expression a.b, ang tuldok na metacharacter (.)ay nangangahulugang anumang character sa pagitan ng aat b. Isaalang-alang ang sumusunod na halimbawa: java RegexDemo .ox "The quick brown fox jumps over the lazy ox." Ang halimbawang ito ay gumagamit .oxng parehong bilang isang regular na expression at The quick brown fox jumps over the lazy ox.bilang input text. RegexDemohinahanap ang teksto para sa mga tugma na nagsisimula sa anumang karakter at nagtatapos sa ox.Ang mga resulta ng pagpapatupad nito ay ang mga sumusunod:

regex = .ox
input = The quick brown fox jumps over the lazy ox.
Found [fox] starting at 16 and ending at 18
Found [ ox] starting at 39 and ending at 41

Sa output ay nakikita natin ang dalawang tugma: foxat ox(na may puwang na character sa harap nito). Ang metacharacter . ay tumutugma sa isang character fsa unang kaso at isang puwang sa pangalawa. Ano ang mangyayari kung papalitan mo ito .oxng isang metacharacter .? Ibig sabihin, kung ano ang nakukuha natin bilang resulta ng sumusunod na command line: java RegexDemo . "The quick brown fox jumps over the lazy ox." Dahil ang tuldok na metacharacter ay tumutugma sa anumang character, RegexDemomaglalabas ng mga tugmang makikita para sa lahat ng mga character (kabilang ang trailing dot character) ng input text:

regex = .
input = The quick brown fox jumps over the lazy ox.
Found [T] starting at 0 and ending at 0
Found [h] starting at 1 and ending at 1
Found [e] starting at 2 and ending at 2
Found [ ] starting at 3 and ending at 3
Found [q] starting at 4 and ending at 4
Found [u] starting at 5 and ending at 5
Found [i] starting at 6 and ending at 6
Found [c] starting at 7 and ending at 7
Found [k] starting at 8 and ending at 8
Found [ ] starting at 9 and ending at 9
Found [b] starting at 10 and ending at 10
Found [r] starting at 11 and ending at 11
Found [o] starting at 12 and ending at 12
Found [w] starting at 13 and ending at 13
Found [n] starting at 14 and ending at 14
Found [ ] starting at 15 and ending at 15
Found [f] starting at 16 and ending at 16
Found [o] starting at 17 and ending at 17
Found [x] starting at 18 and ending at 18
Found [ ] starting at 19 and ending at 19
Found [j] starting at 20 and ending at 20
Found [u] starting at 21 and ending at 21
Found [m] starting at 22 and ending at 22
Found [p] starting at 23 and ending at 23
Found [s] starting at 24 and ending at 24
Found [ ] starting at 25 and ending at 25
Found [o] starting at 26 and ending at 26
Found [v] starting at 27 and ending at 27
Found [e] starting at 28 and ending at 28
Found [r] starting at 29 and ending at 29
Found [ ] starting at 30 and ending at 30
Found [t] starting at 31 and ending at 31
Found [h] starting at 32 and ending at 32
Found [e] starting at 33 and ending at 33
Found [ ] starting at 34 and ending at 34
Found [l] starting at 35 and ending at 35
Found [a] starting at 36 and ending at 36
Found [z] starting at 37 and ending at 37
Found [y] starting at 38 and ending at 38
Found [ ] starting at 39 and ending at 39
Found [o] starting at 40 and ending at 40
Found [x] starting at 41 and ending at 41
Found [.] starting at 42 and ending at 42

Mga klase ng character

Minsan kailangan mong limitahan ang mga laban na hinahanap mo sa isang partikular na hanay ng mga character. Halimbawa, hanapin ang teksto para sa mga patinig a, e, i, oat u, na ang bawat paglitaw ng isang titik ng patinig ay itinuturing na isang tugma. Sa paglutas ng mga naturang problema, tutulungan tayo ng mga klase ng character na tumutukoy sa mga hanay ng mga character sa pagitan ng mga metacharacter ng square bracket ( [ ]). Sinusuportahan ng klase Patternang mga simpleng klase ng character, range class, inverse, union, intersection, at subtraction na klase. Titingnan natin silang lahat ngayon.

Simple Character Classes

Ang isang simpleng klase ng character ay binubuo ng mga character na magkatabi at tumutugma lamang sa mga character na iyon. Halimbawa, [abc]tumutugma ang klase sa mga character a, bat c. Isaalang-alang ang sumusunod na halimbawa: java RegexDemo [csw] cave Tulad ng makikita mo mula sa mga resulta, sa halimbawang ito ay ang karakter lamang ckung saan mayroong tugma sa cave:

regex = [csw]
input = cave
Found [c] starting at 0 and ending at 0

Inverted character classes

Ang isang baligtad na klase ng character ay nagsisimula sa isang metacharacter ^at tumutugma lamang sa mga character na hindi nakapaloob dito. Halimbawa, ang klase [^abc]ay tumutugma sa lahat ng mga character maliban sa a, bat c. Isaalang-alang ang sumusunod na halimbawa: java RegexDemo "[^csw]" cave Tandaan na sa aking operating system (Windows) kinakailangan ang mga dobleng panipi dahil tinatrato ng shell ang mga ito ^bilang isang escape character. Tulad ng nakikita mo, sa halimbawang ito ay ang mga character lamang a, vat natagpuan e, kung saan mayroong mga tugma sa cave:

regex = [^csw]
input = cave
Found [a] starting at 1 and ending at 1
Found [v] starting at 2 and ending at 2
Found [e] starting at 3 and ending at 3

Saklaw ng mga klase ng character

Ang isang range na klase ng character ay binubuo ng dalawang character na pinaghihiwalay ng isang gitling ( -). Ang lahat ng mga character, simula sa character sa kaliwa ng hyphen at nagtatapos sa character sa kanan, ay bahagi ng range. Halimbawa, [a-z]tumutugma ang hanay sa lahat ng maliliit na letrang Latin. Ito ay katumbas ng pagtukoy ng isang simpleng klase [abcdefghijklmnopqrstuvwxyz]. Isaalang-alang ang sumusunod na halimbawa: java RegexDemo [a-c] clown Ang halimbawang ito ay tutugma lamang sa karakter cna may tugma sa clown:

regex = [a-c]
input = clown
Found [c] starting at 0 and ending at 0

Mga Regular na Expression sa Java, Part 2 Regular Expression sa Java, Part 3 Regular Expression sa Java, Part 4 Regular Expression sa Java, Part 5