Question

How to use X{n} , X{n}? and X{n}+ regular expressions (REGEX) in Java

Answer 1

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("", "a{1}", "a{1}?", "a{1}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
Not found

Not found

Not found
   
*/

 

70+ SQL courses for beginners and professionals

Answer 2

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("a", "a{1}", "a{1}?", "a{1}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
a{1}: Found "a" from index 0 to 1

a{1}?: Found "a" from index 0 to 1

a{1}+: Found "a" from index 0 to 1
   
*/

 

70+ SQL courses for beginners and professionals

Answer 3

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("aa", "a{1}", "a{1}?", "a{1}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
a{1}: Found "a" from index 0 to 1
a{1}: Found "a" from index 1 to 2

a{1}?: Found "a" from index 0 to 1
a{1}?: Found "a" from index 1 to 2

a{1}+: Found "a" from index 0 to 1
a{1}+: Found "a" from index 1 to 2
   
*/

 

70+ SQL courses for beginners and professionals

Answer 4

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("aba", "a{1}", "a{1}?", "a{1}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
a{1}: Found "a" from index 0 to 1
a{1}: Found "a" from index 2 to 3

a{1}?: Found "a" from index 0 to 1
a{1}?: Found "a" from index 2 to 3

a{1}+: Found "a" from index 0 to 1
a{1}+: Found "a" from index 2 to 3
   
*/

 

70+ SQL courses for beginners and professionals

Answer 5

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("a", "a{2}", "a{2}?", "a{2}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
Not found

Not found

Not found
   
*/

 

70+ SQL courses for beginners and professionals

Answer 6

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("aba", "a{2}", "a{2}?", "a{2}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
Not found

Not found

Not found
   
*/

 

70+ SQL courses for beginners and professionals

Answer 7

package javaapplication1;
  
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("aababaa", "a{2}", "a{2}?", "a{2}+");
    }
      
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
   
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println("Not found");
        }
    }
}
  
  
/*
run:
   
a{2}: Found "aa" from index 0 to 2
a{2}: Found "aa" from index 5 to 7

a{2}?: Found "aa" from index 0 to 2
a{2}?: Found "aa" from index 5 to 7

a{2}+: Found "aa" from index 0 to 2
a{2}+: Found "aa" from index 5 to 7
   
*/

 

70+ SQL courses for beginners and professionals

Answer 8

package javaapplication1;
   
import java.util.regex.Matcher;
import java.util.regex.Pattern;
   
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("catcatcatcatcat", "cat{3}", "(cat){3}", "(cat){6}", "[cat]{3}");
    }
       
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
    
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println(String.format("%s: Not found\n", regex));
        }
    }
}
   
   
/*
run:
    
cat{3}: Not found

(cat){3}: Found "catcatcat" from index 0 to 9


(cat){6}: Not found

[cat]{3}: Found "cat" from index 0 to 3
[cat]{3}: Found "cat" from index 3 to 6
[cat]{3}: Found "cat" from index 6 to 9
[cat]{3}: Found "cat" from index 9 to 12
[cat]{3}: Found "cat" from index 12 to 15
    
*/

 

70+ SQL courses for beginners and professionals

Answer 9

package javaapplication1;
   
import java.util.regex.Matcher;
import java.util.regex.Pattern;
   
public class Example {
    public static void main(String[] args) {
        // X{n} , X{n}? and X{n}+  (X exactly n times)
        searchREGEX("catcatcatcatcat", "(cat){3}", "(cat){3}?", "(cat){3}+");
        searchREGEX("catcatcatcatcat", "[cat]{3}", "[cat]{3}?", "[cat]{3}+");
    }
       
    private static void searchREGEX(String input, String... regex_list) {
        for (String regex : regex_list) {
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(input);
    
            boolean found = false;
            while (matcher.find()) {
               System.out.println(String.format("%s: Found" + " \"%s\" " + "from index %d to %d",
                                       regex, matcher.group(), matcher.start(), matcher.end()));
               found = true;
            }
            System.out.println();
            if (!found) 
                System.out.println(String.format("%s: Not found\n", regex));
        }
    }
}
   
   
/*
run:
    
(cat){3}: Found "catcatcat" from index 0 to 9

(cat){3}?: Found "catcatcat" from index 0 to 9

(cat){3}+: Found "catcatcat" from index 0 to 9

[cat]{3}: Found "cat" from index 0 to 3
[cat]{3}: Found "cat" from index 3 to 6
[cat]{3}: Found "cat" from index 6 to 9
[cat]{3}: Found "cat" from index 9 to 12
[cat]{3}: Found "cat" from index 12 to 15

[cat]{3}?: Found "cat" from index 0 to 3
[cat]{3}?: Found "cat" from index 3 to 6
[cat]{3}?: Found "cat" from index 6 to 9
[cat]{3}?: Found "cat" from index 9 to 12
[cat]{3}?: Found "cat" from index 12 to 15

[cat]{3}+: Found "cat" from index 0 to 3
[cat]{3}+: Found "cat" from index 3 to 6
[cat]{3}+: Found "cat" from index 6 to 9
[cat]{3}+: Found "cat" from index 9 to 12
[cat]{3}+: Found "cat" from index 12 to 15
    
*/

 

70+ SQL courses for beginners and professionals