java regular expression example

Turn from: http://blog.csdn.net/harryhuang1990/article/details/11888293 In the text analysis of the time we often need to filter out the stop words, punctuation and so on, this article to explain how to identify and delete all the punctuation in the text. Here are three feasible regular expression scenarios, children's shoes try it ^_^ [Java]View plain Copy (1)

I recently learned Java regular expressions, but I have to writeProgramOnly. It is inconvenient, so I made a simple tool. I am playing on my own, with limited levels and a very simple interface. It looks like this: After entering the regular expression and the text to be matched, click the matcher button

results or　　　　　I,the pattern of the x* has been matched with the corresponding characters in text, the next pattern needs to be matched, so the pattern of x* removed　　　　　II,the pattern of the x* with the text of the current letter match completed, the next text needs to be matched, so the current results and text minus one of the results of the combinationb, other conditions directly to the text and pattern each cut one, with the current comparison results together to return.Q: Why does the cur

,} ' cannot match ' o ' in ' Bob ', but can match all o in ' Foooood '. ' O{1,} ' is equivalent to ' o+ '. ' O{0,} ' is equivalent to ' o* '.{n,m} m and n are non-negative integers, where n ? When the character immediately follows any other restriction (*, +,?, {n}, {n,}, {n,m}), the matching pattern is non-greedy. The non-greedy pattern matches the searched string as little as possible, while the default greedy pattern matches as many of the searched strings as possible. For

= "ASFASF.SDFSAF.SDFSDFAS.ASDFASFDASFD.WRQWRWQER.ASFSAFASF.SAFGFDGDSG"; String[] STRs= Str.split ("\ \.")); for(String s:strs) {System.out.println (s); } } Private Static voidgetstrings () {String str= "Rrwerqq84461376qqasfdasdfrrwerqq84461377qqasfdasdaa654645aafrrwerqq84461378qqasfdaa654646aaasdfrrwerqq84461379qqasfdas Dfrrwerqq84461376qqasfdasdf "; Pattern P= Pattern.compile ("QQ (. *?) Qq); Matcher m=P.matcher (str); ArrayListNewArraylist(); while(M.find ()) {Strs.add (M.group

Java identity card Verification and regular expression parsing PackageService;Importjava.text.ParseException;ImportJava.text.SimpleDateFormat;ImportJava.util.regex.Pattern;Importorg.junit.Test; Public classTestregex { Public Static Booleanischinesename (String realname) {returnPattern.matches ("[\u4e00-\u9fa5|] {2,15} ", Realname); } Public Static BooleanIsca

position, the next one to determine if there is a ' * ' unit to match, matching correct removal of the matched part will be the rest of the recursive, the mismatch returns false. Java implementations:1 Public classSolution {2 Public BooleanIsMatch (String s, String p) {3 if(P.length () ==0){4 returnS.length () ==0;5 }6 Else if(S.length () ==0) {7 if(P.length () >1p.charat (1) = = ' * ')return

PackageCom.ict.modules.plateform.tool;ImportJava.util.regex.Matcher;ImportJava.util.regex.Pattern;Importorg.apache.commons.lang3.StringUtils;/*** Regular Expression tool class *@authorHSW **/ Public classRegularutil {/*** Check the phone number * True=ismobile ("18910808534") * False=ismobile ("28910808534") * False=ismobile ("") * FAL Se=ismobile (NULL) *@paramMobilenum *@return */ Public Static Bo

if not matched, otherwise the next comparison. If the next one is ' * ', the position of the PP is moved backwards by two bits, and the SP's position is now a brute force comparison, one for each move backwards.The code is as follows:1 Public classSolution {2 Public Static BooleanIsMatch (String s, String p) {3 if(s = =NULL)4 returnp = =NULL;5 if(p = =NULL)6 returns = =NULL;7 returnHelper (s, p, 0, 0);8 }9 Private Static BooleanHelpe

/** * * @author Zen Johnny * @date April 29, 2018 PM 3:53:55 * */package demo.regex;/* Regular expression: Cut */public class Regexsplitdemo {public static void Splitnames (String string) {string[] names = String.Split ("(, |\\s|\\.|;) + ");//cut by multiple spaces or commas or semicolons, do not use *for (String item:names) System.out.println (item);} Cut file directory public static void Splitdirs (String

// Chinese character range u4E00-u9FA5import java. util. regex. matcher; import java. util. regex. pattern;/************************ create by fzw my website: www.itstack.org * November 19, 2013 * Regular Expression ************************/public class sxtRegex01 {public static void main (String [] args) {p ("check fo

There are many expressions for verifying IP addresses using regular expressions on the Internet. You can search a large number of expressions and write them on your own. However, it is very troublesome and troublesome. It is inevitable that someone else will write a bug. I found a few tests. I don't know any bugs or even the correct IP addresses. Many of them are still vowed, as if I had tested them myself. Today, I found a

Private Set getcodes (String s) { Setnew hashset(); = Codepattern.matcher (s); while (Matcher.find ()) { Resultset.add (matcher.group (1)); } return resultSet; } Private Static Pattern Codepattern = Pattern.compile ("\" code\ ": \" (\\w+) \ ",");Java Regular expression-capturing group

S:arr) * { $ Ts.add (s);Panax Notoginseng } -Regex= "0* (\\d+)"; the for(String s:ts) + { ASystem.out.println (S.replaceall (Regex, "$")); the } + } -}View CodeOperation Result:1 192.168.10.34 2 127.0.0.1 3 105.70.11.75 4 3.3.3.3 5 6 7 192.168.010.034 8 127.000.000.001 9 105.070.011.075 003.003.003.003 A 3.3.3.3 105.70.11.75 127.0.0.1 192.168.10.34 View CodeWhen the extra 0 is removed, the mode used is: "0* (\\d+)", so that even if all is 0, the

ImportJava.util.regex.Matcher; ImportJava.util.regex.Pattern; Importjava.util.regex.PatternSyntaxException; Public classPhoneformatcheckutils {/*** Mainland or Hong Kong numbers are available*/ Public Static BooleanIsphonelegal (String str)throwspatternsyntaxexception {returnIschinaphonelegal (str) | |Ishkphonelegal (str); } /*** Mainland Mobile phone number 11 digits, match format: first three bit fixed format + 8 digits any number * This method in the first three bit format has:

*/publicstatic booleancheckfax (stringfax) {Stringregex= "^ (0\\d{2}-\\d{8} (-\\d{1,4})?) | (0\\d{3}-\\d{7,8} (-\\d{1,4})?) $ "; Returncheck (Fax,regex);} /*** Verification Email ** @param email* @return */publicstatic booleancheckemail (stringemail) {Stringregex= "^\\s*\\w+ (?: \ \. {0,1} [\\w-]+) *@[a-za-z0-9]+ (?: [-.] [a-za-z0-9]+] *\\. [a-za-z]+\\s*$]; Returncheck (Email,regex);} /***nbSP; Verify non-empty ** @param notEmputy* @return */publicstatic Booleanchecknotemputy (stringnotemputy)

In this case, the regular expression optimization, mainly for the current commonly used NFA pattern regular expressions, in detail can be referred to: regular expression matching parsing process analysis (regular

! System.out.println (Ip2[i]); } /** Check the email address! */String Mail= "[Email protected]"; BooleanBF = Mail.matches ("\\[email protected]\\w+ (\\.\\w+) +"); System.out.println (Mail+ ":" +BF); String SR= "fsdfs.12345"; Pattern P= Pattern.compile ("\\w+"); Matcher m=P.matcher (SR); while(M.find ()) {System.out.println (M.group ()); } /** Regular expression is to realize the IP address o

, such as replacing all the Cos in a string with sin. Match a single character(1) Matching plain textRegular expressions can contain plain text (or even plain text).There may be multiple matching results when matching plain text, and most of the regular expression implementations provide a mechanism for finding all of the matching results (usually returning an array).Re