/* Author: LukArToDo Created: 22.01.2018 Description: Examples of using regex expressions */ import java.util.regex.Matcher; import java.util.regex.Pattern; import static java.lang.System.out; public class RegexExample { public static void main(String...ar){ out.println("For a better understanding, read the comments carefully :)"); testingExamples(); lookBehindAhead(); substitutionsGroupingAndBackreference(); manipulateStringWithRegex(); //matches, replace, split... } static void testingExamples() { out.println("\ntestIsTrue()\n"+ isTrue("true") +" 'true'\n"+ isTrue("true2")+" 'true2'\n"+ isTrue("True")+" 'True"); out.println("\ntestIsTrueVersion2()\n"+ isTrueVersion2("true")+" 'true'\n"+ isTrueVersion2("true2")+" 'true2'\n"+ isTrueVersion2("True")+" 'True'"); out.println("\ntestIsTrueOrYes()\n"+ isTrueOrYes("true")+" 'true'\n"+ isTrueOrYes("yes")+" 'yes'\n"+ isTrueOrYes("Yes")+" 'Yes'\n"+ isTrueOrYes("no")+" 'no'"); out.println("\ntestContainsTrue()\n"+ containsTrue("thetruewithin")+" 'thetruewithin'"); out.println("\ntestIsThreeLetters()\n"+ isThreeLetters("abc")+" 'abc'\n"+ isThreeLetters("abcd")+" 'abcd'"); out.println("\ntestisNoNumberAtBeginning()\n"+ isNoNumberAtBeginning("abc")+" 'abc'\n"+ isNoNumberAtBeginning("1abcd")+" '1abcd'\n"+ isNoNumberAtBeginning("a1bcd")+" 'a1bcd'\n"+ isNoNumberAtBeginning("asdfdsf")+" 'asdfdsf'"); out.println("\ntestisNoNumberAtTheEnd()\n"+ isNoNumberAtTheEnd("abc1") +" 'abc1'\n"+ isNoNumberAtTheEnd("abc1d")+" 'abc1d'\n"+ isNoNumberAtTheEnd("1") + " '1'"); out.println("\ntestisIntersection()\n"+ isIntersection("1")+" '1'\n"+ isIntersection("abcksdfkdskfsdfdsf")+" 'abcksdfkdskfsdfdsf'\n"+ isIntersection("skdskfjsmcnxmvjwque484242")+ " 'skdskfjsmcnxmvjwque484242'"); out.println("\ntestLessThenThreeHundred()\n"+ isLessThenThreeHundred("288")+" '288'\n"+ isLessThenThreeHundred("3288")+" '3288'\n"+ isLessThenThreeHundred("328 8")+" '328 8'\n"+ isLessThenThreeHundred("1")+" '1'\n"+ isLessThenThreeHundred("99")+" '99'\n"+ isLessThenThreeHundred("300")+" '300'"); } // returns true if the string matches exactly "true" static boolean isTrue(String s){ return s.matches("true"); } // returns true if the string matches exactly "true" or "True" static boolean isTrueVersion2(String s){ // regex "[tT]rue" we can write as: "(?i)true" because (?i) makes the regex case insensitive return s.matches("[tT]rue"); } // returns true if the string matches exactly "true" or "True" // or "yes" or "Yes" static boolean isTrueOrYes(String s){ // regex "[tT]rue|[yY]es" we can write as "(?i)true|yes" because (?i) makes the regex case insensitive return s.matches("[tT]rue|[yY]es"); } // returns true if the string contains exactly "true" static boolean containsTrue(String s){ // regex ".*true.*" means: string start with several or zero of any character(except \n), follows with 'true' and ends with several or zero any character(except \n) return s.matches(".*true.*"); } // returns true if the string contains of three letters static boolean isThreeLetters(String s){ // this regex we can write as [\\w]{3} because expresion \\w represent letters return s.matches("[a-zA-Z]{3}"); // simpler from for // return s.matches("[a-Z][a-Z][a-Z]"); } // returns true if the string does not have a number at the beginning static boolean isNoNumberAtBeginning(String s){ // regex ^[^\\d].* we can split to three sections: ^ then [^\\d] and .* // first part ^ of above regex means 'at start of string or line' // second part [^\\d] means non-digits characters (we can write and as [\\D] // third part .* means that non-digits characters follow any character except \n (.) several or zero times return s.matches("^[^\\d].*"); } // returns true if the string does not have a number at the end static boolean isNoNumberAtTheEnd(String s) { //regex ".*[^\\d]$" we can write as ".*[\\D]$" and means taht string can start with any character (except \n) and ends with non-digits character // sign '$' means at the end of line return s.matches(".*[^\\d]$"); } // returns true if the string contains a arbitrary number of characters except b static boolean isIntersection(String s){ // regex [\\w&&[^b]] means find does string contains any letter but not letter 'b' // above regex with * means find does string contains several or zero letter but not letter 'b' return s.matches("([\\w&&[^b]])*"); } // returns true if the string contains a number less than 300 static boolean isLessThenThreeHundred(String s){ //first section [^0-9]* means that string can start with non-digits characters (a123) because ^ mean negation (non). //If we write this part without * then we required that string start with non-digit character. //So, * mean that statement [^0-9]* finds no or several non-digits characters // Note: expression [^0-9] we can replace with [\\D] //second section [12]?[0-9]{1,2} means that first digit start with 1 or 2, and folowing digits can be any digits occur at a maximum of two times // Note: expression [0-9] we can replace with [\\d] //third section is same as first and means that string can ends or not with non-digits characters return s.matches("[^0-9]*[12]?[0-9]{1,2}[^0-9]*"); } static void lookBehindAhead() { /* Examples: Given the string "foobarbarfoo": bar(?=bar) finds the 1st bar ("bar" which has "bar" after it) bar(?!bar) finds the 2nd bar ("bar" which does not have "bar" after it) (?<=foo)bar finds the 1st bar ("bar" which has "foo" before it) (? find "ee" in "seek" String repeated="aaabbbcccddd"; out.println("\nWe want to split the string at groups of same chars, so we need to find out the 'boundary' between each group. We using Java's syntax: (?<=(.)(?!\\1)) for positive look-behind '?<=(.)' to pick the previous char and then a negative look-ahead '(?!\\1)' with a back reference '\\1' to verify that the next char is not the same as the previous one."); for(String s: repeated.split("(?<=(.)(?!\\1))")) out.println(s); String exmp="a9 7c 4t zz"; out.println("\nIf we want split next string '"+exmp+"' by letter which comes after digit including this letter we use next regex: ((?<=\\d\\w)(?!\\1))"); for(String s:exmp.split("((?<=\\d\\w)(?!\\1))")) out.println(s); out.println("But, if we want find letter which comes after digit with Pattern and Matcher we using next pattern: (?<=\\d)\\w "); patternMatches(exmp,"(?<=\\d)\\w"); } //Substitutions,Grouping And Backreference static void substitutionsGroupingAndBackreference() { out.println(); // group of expression is within brackets: (\\w+) is group $1, (\\s) is $2 group $2 and (\\w+) is group $3 // replace given string on next way: group3 + group 2 +group 1: out.println("one two".replaceAll("\\b(\\w+)(\\s)(\\w+)\\b", "$3$2$1")+" 'one two'"); // we can named each group of expression: out.println("one two".replaceAll("\\b(?\\w+)(\\s)(?\\w+)\\b", "${word2} ${word1}")+" 'one two' with named group"); } static void manipulateStringWithRegex() { out.println("\nManipulate string with regex:"); String EXAMPLE_TEST = "This is my small example string which I'm going to use for pattern matching."; //string.matches(regex) -> Evaluates if "regex" matches string. Returns only true if the WHOLE string can be matched. out.println(EXAMPLE_TEST.matches("\\w.*")); //string.split(regex) -> Creates an array with substrings of s divided at occurrence of "regex". "regex" is not included in the result. String[] splitString = (EXAMPLE_TEST.split("\\s+")); out.println(splitString.length);// should be 14 for (String string : splitString) out.println(string); // string.replaceAll(regex,replacment) -> Replaces all occurances of "regex" with "replacement. // replace all whitespace with tabs out.println(EXAMPLE_TEST.replaceAll("\\s+", "\t")); out.println("\nFormat date dd/mm/yyyy using regex:"); out.println("22012018".replaceAll("(\\d{2})(\\d{2})(\\d{4})","$1/$2/$3")); } static void patternMatches(String exmp,String regex) { // PATTERN and MATCHER examples: Pattern pattern = Pattern.compile(regex); // in case you would like to ignore case sensitivity, // you could use this statement: //Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE); Matcher matcher = pattern.matcher(exmp); // check all occurance while (matcher.find()){ out.print("Start index: " + matcher.start()); out.print(" End index: " + matcher.end() + " found: "); out.println(matcher.group()); } } } /* SINGLE CHARACTERS Use To match any character [set] In that set [^set] Not in that set [a–z] In the a-z range [^a–z] Not in the a-z range . Any except \n (new line) \char Escaped special character CHARACTER CLASSES Use To match character \p{ctgry} In that Unicode category or block \P{ctgry} Not in that Unicode category or block \w Word character \W Non-word character \d Decimal digit \D Not a decimal digit \s White-space character \S Non-white-space char QUANTIFIERS Greedy Lazy Matches * *? 0 or more times + +? 1 or more times ? ?? 0 or 1 time {n} {n}? Exactly n times {n,} {n,}? At least n times {n,m} {n,m}? From n to m times ANCHORS Use To specify position ^ At start of string or line \A At start of string \z At end of string \Z At end (or before \n at end) of string $ At end (or before \n at end) of string or line \G Where previous match ended \b On word boundary \B Not on word boundary GROUPS Use To define (exp) Indexed group (?exp) Named group (?exp) Balancing group (?:exp) Noncapturing group (?=exp) Zero-width positive lookahead (?!exp) Zero-width negative lookahead (?<=exp) Zero-width positive lookbehind (?exp) Non-backtracking (greedy) BACKREFERENCES Use To match \n Indexed group \k Named group ALTERNATION Use To match a |b Either a or b (?(exp) yes | no) yes if exp is matched no if exp isn't matched (?(name) yes | no) yes if name is matched no if name isn't matched INLINE OPTIONS Option Effect on match i Case-insensitive m Multiline mode n Explicit (named) s Single-line mode x Ignore white space */

Regex Examples