Դաս 16.2։ Java – Regular Expressions

0

Replacement մեթոդներ

Replacement method-ը օգտակար է տեքստը՝ մուտքային տողում փոխարինելու համար

Sr.No. Method & Description
1 public Matcher appendReplacement(StringBuffer sb, String replacement)

Իրականացնում է ոչ տերմինալային append-and-replace քայլը

2 public StringBuffer appendTail(StringBuffer sb)

Իրականացնում է տերմինալային append-and-replace քայլը

3 public String replaceAll(String replacement)

Փոխարինում է մուտքային հաջորդականության յուրաքանչյուր հաջորդականությունը, որը համապատասխանում է շաբլոնին տրված փոխարինման տողով:

4 public String replaceFirst(String replacement)

Փոխարինում է առաջին հաջորդականության յուրաքանչյուր հաջորդականությունը, որը համապատասխանում է շաբլոնին տրված փոխարինման տողով:

5 public static String quoteReplacement(String s)

Վերադարձնում է տողային փոխարինումը սահմանված տողի համար։ Այս մեթոդը ստեղծում է մի տող, որը պետք աշխատի որպես փոխարինող s Matcher դասի appendReplacement մեթոդում:

 

Start և end մեթոդներ

Ստորև բերված օրինակում ցույց է տրված, թե քանի անգամ է «cat» բառը տողում հայտնվում է մուտքային տողում

Օրինակ՝

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);   // get a matcher object

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 2s

tart(): 4

end(): 7

Match number 3

start(): 8

end(): 11

Match number 4

start(): 19

end(): 22

 

Դուք կարող եք տեսնել, որ այս օրինակում օգտագործված են բառերի «սահմաններ», որպեսզի “c” “a” “t” տառերը ավելի երկար բառի ենթատող չդառնան: Այն տրամադրում է որոշակի օգտակար տեղեկություններ այն մասին, թե մուտքային տողի որ հատվածում է տեղի ունեցել համապատասխանում:

start մեթոդը վերադարձնում է այն հաջորդականության start index-ը, որոնք նախորդ գործողության ընթացքում գրավված են տվյալ խմբի կողմից, իսկ end-ը վերադարձնում է համապատասխանեցված վերջին տառի սիմվոլը , + 1։

Համապատասխանումները (matches)  և 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 մեթոդներ

 

մեթոդները փոխարինում են տեքստը, որը համապատասխանում է տրված regular expression-ին։ Ինչպես բխում է վերջինիս անուններից 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 class-ը տրամադրում է նաև appendReplacement և appendTail մեթոդները։

Օրինակ՝

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

// get a matcher object

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 Class մեթոդներ

PatternSyntaxException-ը չսուգված բացառություն է, որը ցույց է տալիս սխալը հերթական արտահայտության շարահյուսությունում։ PatternSyntaxException դասը տրամադրում է հետևյալ մեթոդները, որոնք կօգնեն ձեզ որոշել, թե ինչն է սխալ։

Sr.No. Method & Description
1 public String getDescription()

Տալիս է սխալի նկարագրությունը

2 public int getIndex()

Տալիս է error index-ը

3 public String getPattern()

Տալիս է ռեգուլիար արտահայտության սխալ շաբլոնը։

4 public String getMessage()

Վերադարձնում է բազմատող տողը, որը պարունակում է շարահյուսության սխալի և դրա ինդեքսի նկարագրությունը, ռեգուլիար արտահայտության սխալի շաբլոնը և սխալի վիզուալ ցուցումը»

 

Հարգելի ընթերցող, խնդրում ենք չմոռանալ like տալ մեր ֆեյսբուքյան էջին, քանի որ նորությունների մեծ մասը առաջինը տեղադրվում է հենց այնտեղ։ Ինչպես նաև հետևեք մեզ այլ սոցիալական ցանցերում և, իհարկե, գրանցվեք մեր բլոգում։

Share.