What are the differences among greedy, reluctant and possessive quantifiers?

Quantifiers are used to indicate the number of instances of the element (to which they are applied in the regular expression) required for a successful match. Java supports three quantifier types namely greedy, reluctant, and possessive. Greedy quantifiers try to match as much as possible while their reluctant counterparts (with ? at the end) try to match the least required to fulfill a match. What this means is that a greedy quantifier will try to match the entire line whether or not a successful match has occurred. It can turn into real performance overhead when the target text is big. Reluctant (or lazy) quantifiers quit as soon as a successful match occurs without bothering to run through the entire line. Possessive quantifiers (with + appended) are useful in optimizing the match operations since they don't keep the prior match states around (Quote from Simplify Pattern Matching by Anant Athale)

For example, if your text is "abcba abcba":

• The greedy pattern "ab.*ba" will match the substring "abcba abcba" -- the largest substring that fits the pattern

  public class Program
  {
   public static void main(String[] args){
      
     Scanner s = new Scanner("abcba abcba");  
     Pattern p = Pattern.compile("ab.*ba");
     s.findInLine(p);  
     try {
       MatchResult result = s.match();
     
       System.out.println(result.group());
       for (int i=1; i<=result.groupCount(); i++)
         System.out.println(result.group(i)); 
       s.close(); 
     }
     catch(IllegalStateException e) {
       System.out.println("No match");
     }
   }
  }
  

  The output is "abcba abcba".

• The reluctant pattern "ab.*?ba" will match the substring "abcba" -- the first substring that fits the pattern

  public class Program
  {
   public static void main(String[] args){
      
     Scanner s = new Scanner("abcba abcba");  
     Pattern p = Pattern.compile("ab.*?ba");
     s.findInLine(p);  
     try {
       MatchResult result = s.match();
       System.out.println(result.group());
       for (int i=1; i<=result.groupCount(); i++)
         System.out.println(result.group(i)); 
       s.close(); 
     }
     catch(IllegalStateException e) {
       System.out.println("No match");
     }
   }
  }
  

  The out put is "abcba".

• The possessive pattern "ab.*+ba" will not match at all, because the possessive .*+ will gobble up all of "cba abcba", including the closing "ba", and never let go of it again.

  public class Program
  {
   public static void main(String[] args){
      
     Scanner s = new Scanner("abcba abcba");  
     Pattern p = Pattern.compile("ab.*+ba");
     s.findInLine(p);  
     try {
       MatchResult result = s.match();
       System.out.println(result.group());
       for (int i=1; i<=result.groupCount(); i++)
       System.out.println(result.group(i)); 
       s.close(); 
     }
     catch(IllegalStateException e) {
       System.out.println("No match");
     }
   }
  }
  

  The output is "No match".