expresiones regulares Java

expresión regular define la cadena patrón.

Las expresiones regulares se pueden utilizar para buscar, editar, o el procesamiento de texto.

Las expresiones regulares no están limitados a un determinado idioma, pero existen diferencias sutiles en cada idioma.

Java y Perl expresiones regulares es la más parecida.

java.util.regex paquete incluye las siguientes tres categorías:

• categorías patrón:

  modelo objeto es una representación regular la expresión compilador. Patrón de clase no tiene constructor público. Para crear un objeto del modelo, primero debe llamar a su método de compilación estática pública que devuelve un objeto del modelo. Este método toma una expresión regular como primer argumento.

• matcher categorías:

  matcher objeto es la interpretación de la cadena de entrada y operación de adaptación del motor. Al igual que la clase Pattern, Matcher no tiene ningún constructor público. Es necesario llamar el objeto patrón de coincidencias método para obtener un objeto Matcher.

• PatternSyntaxException:

  PatternSyntaxException es una clase de excepción no obligatoria que representa un regular errores de sintaxis patrón de expresión.

grupo de captura

grupos de captura son múltiples caracteres cuando una sola unidad de métodos de tratamiento, a través de los distintos grupos entre paréntesis para crear.

Por ejemplo, la expresión regular (perro) crea un solo grupo, el grupo que contiene "d", "o" y "g".

grupo de captura mediante el cálculo de su paréntesis de apertura numerados de izquierda a derecha. Por ejemplo, en la expresión ((A) (B (C))), hay cuatro de tales grupos:

• ((A) (B (C)))
• (A)
• (B (C))
• (C)

Llamando al objeto matcher manera groupCount para ver cuántos paquetes expresión. groupCount método devuelve un int que representa el objeto matcher actualmente cuenta con varios grupos de captura.

Hay un grupo especial (grupo 0), que representa siempre la totalidad de la expresión. El grupo no está incluido en el valor de retorno groupCount.

Ejemplos

El siguiente ejemplo muestra cómo encontrar una cadena de números de una cadena dada:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    public static void main( String args[] ){

      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // 创建 Pattern 对象
      Pattern r = Pattern.compile(pattern);

      // 现在创建 matcher 对象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
   }
}

Los ejemplos anteriores resultados compilados son los siguientes:

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

sintaxis de expresiones regulares

métodos de la clase Matcher

Método Índice

Índice métodos proporcionan valores de índice de utilidad indican con precisión dónde encontrar las coincidencias cadena de entrada:

Métodos de investigación

Los métodos utilizados para comprobar la cadena de entrada y devuelve un valor booleano que indica si el patrón se encuentra:

método de sustitución

Alternativa es reemplazar una cadena en el método de entrada de texto:

iniciar y fin del método

Este es un ejemplo del número de apariciones en la cadena de entrada para el recuento de la palabra aparece "gato":

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
                                    "cat cat cat cattie cat";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // 获取 matcher 对象
       int count = 0;

       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Los ejemplos anteriores resultados compilados son los siguientes:

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Esto se puede ver usando el ejemplo límites de las palabras, para asegurar que la letra "c" "a" "t" no es sólo un largo subseries de palabras. También proporciona información útil acerca de la cadena de entrada se corresponde posiciones.

método Start devuelve la operación durante el partido anterior, de entre el grupo capturado subsecuencia determinado índice inicial, termina el método de hacer coincidir el último índice más un carácter.

partidos y método lookingat

partidos y métodos lookingat se utilizan para tratar de coincidir con una secuencia de patrón de entrada. Son diferentes de los requisitos de todo el partido secuencia de coincidencias, pero no lookingat necesarios.

Estos dos métodos se utilizan a menudo en comienza la cadena de entrada.

A través del siguiente ejemplo para explicar esta función:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);

       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
   }
}

Los ejemplos anteriores resultados compilados son los siguientes:

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst métodos y replaceAll

Método replaceFirst y replaceAll utiliza para sustituir el texto expresiones regulares. La diferencia está, replaceFirst sustituir el primer partido, replaceAll reemplazar todas las coincidencias.

En el siguiente ejemplo para explicar esta característica:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

Los ejemplos anteriores resultados compilados son los siguientes:

The cat says meow. All cats say meow.

appendReplacement métodos y appendTail

clase Matcher también proporciona un método para appendTail appendReplacement y reemplazar texto:

Mira el siguiente ejemplo para explicar esta característica:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Los ejemplos anteriores resultados compilados son los siguientes:

-foo-foo-foo-

métodos de clase PatternSyntaxException

PatternSyntaxException es una clase de excepción no obligatoria, lo que indica un error de sintaxis regulares patrón de expresión.

PatternSyntaxException clase proporciona los siguientes métodos para ayudarnos a ver lo que ha ocurrido un error.