Cuantificadores en Java

Requisito previo: expresiones regulares en Java

Los cuantificadores en Java permiten a los usuarios especificar el número de ocurrencias con las que comparar. A continuación se muestran algunos cuantificadores de uso común en Java.

X*        Zero or more occurrences of X
X?        Zero or One occurrences of X
X+        One or More occurrences of X
X{n}      Exactly n occurrences of X 
X{n, }    At-least n occurrences of X
X{n, m}   Count of occurrences of X is from n to m

Los cuantificadores anteriores se pueden convertir en codiciosos, reacios y posesivos.

Cuantificador codicioso (predeterminado) 

Por defecto, los cuantificadores son Greedy. Los cuantificadores codiciosos intentan hacer coincidir el texto más largo que coincide con un patrón determinado. Los cuantificadores codiciosos funcionan leyendo primero la string completa antes de intentar cualquier coincidencia. Si todo el texto no coincide, elimine el último carácter y vuelva a intentarlo, repitiendo el proceso hasta que encuentre una coincidencia.  

// Java program to demonstrate Greedy Quantifiers
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
class Test
{
    public static void main(String[] args)
    {
        // Making an instance of Pattern class
        // By default quantifier "+" is Greedy
        Pattern p = Pattern.compile("g+");
  
        // Making an instance of Matcher class
        Matcher m = p.matcher("ggg");
  
        while (m.find())
            System.out.println("Pattern found from " + m.start() +
                               " to " + (m.end()-1));
  
    }
}

Pattern found from 0 to 2

Explicación: El patrón g+ significa una o más apariciones de g . El texto es ggg . El comparador codicioso coincidiría con el texto más largo incluso si partes del texto coincidente también coinciden. En este ejemplo, g y gg también coinciden, pero el comparador codicioso produce ggg .

Cuantificador reacio (agregando un ? después del cuantificador) 

Este cuantificador utiliza el enfoque opuesto a los cuantificadores codiciosos. Comienza con el primer carácter y procesa un carácter a la vez. 

// Java program to demonstrate Reluctant Quantifiers
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
class Test
{
    public static void main(String[] args)
    {
        // Making an instance of Pattern class
        // Here "+" is a Reluctant quantifier because
        // a "?' is appended after it.
        Pattern p = Pattern.compile("g+?");
  
        // Making an instance of Matcher class
        Matcher m = p.matcher("ggg");
  
        while (m.find())
            System.out.println("Pattern found from " + m.start() +
                               " to " + (m.end()-1));
  
    }
}

Pattern found from 0 to 0
Pattern found from 1 to 1
Pattern found from 2 to 2

Explicación: dado que el cuantificador es reacio, hace coincidir la parte más corta de la prueba con el patrón. Procesa un carácter a la vez.

Cuantificador posesivo (agregando un + después del cuantificador) 

Este cuantificador coincide con tantos caracteres como sea posible, como un cuantificador codicioso. Pero si la string completa no coincide, entonces no intenta eliminar los caracteres del final.

// Java program to demonstrate Possessive Quantifiers
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
class Test
{
    public static void main(String[] args)
    {
        // Making an instance of Pattern class
        // Here "+" is a Possessive quantifier because
        // a "+' is appended after it.
        Pattern p = Pattern.compile("g++");
  
        // Making an instance of Matcher class
        Matcher m = p.matcher("ggg");
  
        while (m.find())
            System.out.println("Pattern found from " + m.start() +
                               " to " + (m.end()-1));
    }
}

Pattern found from 0 to 2

Explicación: Obtenemos el mismo resultado que Greedy porque todo el texto coincide con el patrón.

Diferencia entre cuantificadores codiciosos y posesivos

// Java program to demonstrate difference
// between Possessive and Greedy Quantifiers
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
class Test
{
    public static void main(String[] args)
    {
        // Create a pattern with Greedy quantifier
        Pattern pg = Pattern.compile("g+g");
 
        // Create same pattern with possessive quantifier
        Pattern pp = Pattern.compile("g++g");        
 
        System.out.println("Using Greedy Quantifier");
        Matcher mg = pg.matcher("ggg");
        while (mg.find())
            System.out.println("Pattern found from " + mg.start() +
                               " to " + (mg.end()-1));
 
        System.out.println("\nUsing Possessive Quantifier");
        Matcher mp = pp.matcher("ggg");
        while (mp.find())
            System.out.println("Pattern found from " + mp.start() +
                               " to " + (mp.end()-1));
 
    }
}

Using Greedy Quantifier
Pattern found from 0 to 2

Using Possessive Quantifier

En el ejemplo anterior, dado que el primer cuantificador es codicioso, g+ coincide con toda la string. Si hacemos coincidir g+ con una string completa, g+g no coincide, el cuantificador Greedy elimina el último carácter, hace coincidir gg con g+ y encuentra una coincidencia. En el cuantificador Posesivo, empezamos como Greedy. g+ coincide con toda la string, pero hacer coincidir g+ con toda la string no hace coincidir g+g con ggg . A diferencia de Greedy, dado que el cuantificador es posesivo, nos detenemos en este punto.

Este artículo es una contribución de Rahul Agarwal . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.