La interfaz en Java se utiliza para lograr la abstracción. También se considera como el modelo para la clase. Una interfaz solo puede contener métodos abstractos, pero puede o no contener variables. En otras palabras, una interfaz solo puede contener métodos abstractos y variables. Java admite herencia múltiple solo a través de interfaces. Por lo tanto, una interfaz tiene un alcance más amplio en Java.
Este artículo se centra en la interfaz MatchResult.
Interfaz de resultado de coincidencia:
La interfaz MatchResult en Java significa el resultado o la conclusión de una operación de coincidencia. Contiene la definición de ciertos métodos de consulta que se pueden usar para determinar el resultado de la coincidencia con una expresión regular. Tenga en cuenta que no podemos alterar los límites del grupo/grupo ni los límites de coincidencia mediante la interfaz MatchResult, pero se pueden ver fácilmente a través de la interfaz. Esta interfaz se introdujo en la versión 1.5 de Java.
Esta interfaz se puede declarar usando la siguiente sintaxis,
Sintaxis:
public interface MatchResult
Métodos de la interfaz MatchResult
Los métodos de consulta de la interfaz MatchResult se analizan en detalle a continuación.
1. Método start(): este método se utiliza para devolver el índice de inicio del partido.
Sintaxis:
int start()
Valor devuelto:
- entero: representa el índice del primer carácter que tiene una coincidencia
Ejemplo:
Java
// Java program to illustrate the working of start() method
import java.io.*;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class GFG {
// Initializing regular expression string
private static final String regularExpression
= "(.*)(\\d+)(.*)";
// Initializing input string
private static final String input
= "Hello World!, 41346, these are the numbers.";
// Main method
public static void main(String[] args)
{
// Compiling the given regular expression string
Pattern myPattern
= Pattern.compile(regularExpression);
// Applying matcher operation
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// Retrieve the MatchResult Object
MatchResult myResult
= myMatcher.toMatchResult();
// Printing the starting index of the match
System.out.println(
"Starting index of the match: "
+ myResult.start());
}
}
}
Start index of the match: 0
2. start(int group): Este método devuelve el índice inicial de la secuencia que ha sido capturada por el grupo dado durante el partido.
Sintaxis:
int start(int index)
Parámetros:
- index: Representa el índice del grupo de captura en el patrón del matcher.
Valor devuelto:
- entero no negativo: representa el índice del primer carácter que tiene el grupo
- -1: Solo cuando la coincidencia es exitosa pero el grupo no coincide con nada
Ejemplo:
Java
// Java program to illustrate the working
// of start(int index) method
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class GFG {
// Initializing the regular expression string
private static final String regularExpression
= "(.*)(\\d+)(.*)";
// Initializing the input string
private static final String input
= "Hello World!, 41346, these are the numbers.";
// Main method
public static void main(String[] args)
{
// Compiling the regular expression string
Pattern myPattern
= Pattern.compile(regularExpression);
// Applying matcher operation
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// Retrieve the MatchResult Object
MatchResult myResult
= myMatcher.toMatchResult();
// Prints the start index of the sequence
// that was held by the given group during the
// match.
System.out.println("Second Capturing Group: "
+ myResult.start(1));
}
}
}
Second Capturing Group: 0
3. end(): este método devuelve el desplazamiento cuando coincide el último carácter.
Sintaxis:
int end()
Tipo de devolución: devuelve el desplazamiento después del último carácter coincidente.
Ejemplo:
Java
// Java program to illustrate the working of end() method
import java.io.*;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class GFG {
// Initializing the regular expression string
private static final String regularExpression
= "(.*)(\\d+)(.*)";
// Initializing the input string
private static final String input
= "Hello World!, 41346, these are the numbers.";
// Main method
public static void main(String[] args)
{
// Compiling the regular expression string
Pattern myPattern
= Pattern.compile(regularExpression);
// Applying the matcher operation
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// Retrieve the MatchResult object
MatchResult myResult
= myMatcher.toMatchResult();
// Prints the offset following the last
// character matched
System.out.println("First Capturing Group: "
+ myResult.end());
}
}
}
First Capturing Group: 43
4. end(int index): este método devuelve el desplazamiento cuando coincide el último carácter.
Sintaxis:
int end(int index)
Parámetro:
- index: Representa el índice del grupo de captura en el patrón del matcher.
Tipo de devolución: devuelve el desplazamiento después del último carácter coincidente.
Ejemplo:
Java
// Java program to illustrate the working
// of end(int index) method
import java.io.*;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class GFG {
private static final String regularExpression
= "(.*)(\\d+)(.*)";
private static final String input
= "Hello World!, 41346, these are the numbers.";
public static void main(String[] args)
{
// Compiling regular expression string
Pattern myPattern
= Pattern.compile(regularExpression);
// applying matcher operation
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// get the MatchResult Object
MatchResult myResult
= myMatcher.toMatchResult();
// Prints the offset after the last
// character of the sequence held by
// the given group at the time of match.
System.out.println("Second Capturing Group: "
+ myResult.end(1));
}
}
}
Second Capturing Group: 18
5. group(): este método devuelve la secuencia de entrada que coincidió con la coincidencia anterior.
Sintaxis:
String group()
Tipo de devolución:
- Una string: la secuencia que coincidió con la coincidencia anterior.
Ejemplo:
Java
// Java program to illustrate the working of group() method
import java.io.*;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class GFG {
// Initializing regular expression string
private static final String regularExpression
= "(.*)(\\d+)(.*)";
// Initializing input string
private static final String input
= "Hello World!, 41346, these are the numbers.";
// Main() method
public static void main(String[] args)
{
// Compiling regular expression
Pattern myPattern
= Pattern.compile(regularExpression);
// Initiating the matcher object
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// Initiating the MatchResult object
MatchResult myResult
= myMatcher.toMatchResult();
// Prints the input sequence matched by the
// previous match.
System.out.println("First Capturing Group"
+ myResult.group());
}
}
}
First Capturing GroupHello World!, 41346, these are the numbers.
6. grupo (índice int): este método se utiliza para devolver la secuencia de entrada que tenía el grupo especificado en el momento de la operación de coincidencia anterior.
Sintaxis:
int group(int index)
Parámetros:
- índice: el índice del grupo que se captura en el patrón de este comparador.
Tipo de devolución:
- Una string: representa una secuencia que ha sido capturada por el grupo en el momento del partido anterior
- nulo: si el grupo no puede coincidir con ninguna parte de la entrada.
Ejemplo:
Java
// Java program to illustrate the working
// of group(int index) method
import java.io.*;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class GFG {
// Initializing regular expression string
private static final String regularExpression
= "(.*)(\\d+)(.*)";
// Initializing input string
private static final String input
= "Hello World!, 41346, these are the numbers.";
// Main method
public static void main(String[] args)
{
// Compiling regular expression
Pattern myPattern
= Pattern.compile(regularExpression);
// Instantiating matcher object
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// Instantiating MatchResult object
MatchResult myResult
= myMatcher.toMatchResult();
// Prints the input subsequence that was held
// by the given group during the last match
// occurred.
System.out.println(
"Second Capturing Group - Match String: "
+ myResult.group(1));
}
}
}
Second Capturing Group - Match String: Hello World!, 4134
7. groupCount(): este método especifica el número de grupos de captura en el patrón del resultado de la coincidencia.
Sintaxis:
int groupCount()
Tipo de devolución:
- entero: Representa el número de grupos de captura en el patrón del emparejador.
Ejemplo:
Java
// Java program to illustrate the working
// of groupCount() method
import java.io.*;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class GFG {
// Regular expression
private static final String regularExpression
= "(.*)(\\d+)(.*)";
// Input string
private static final String input
= "Hello World!, 41346, these are the numbers.";
public static void main(String[] args)
{
// Compiling regular expression
Pattern myPattern
= Pattern.compile(regularExpression);
// Instantiating a matcher object
Matcher myMatcher = myPattern.matcher(input);
if (myMatcher.find()) {
// Instantiating a MatchResult Object
MatchResult myResult
= myMatcher.toMatchResult();
// Prints the number of capturing groups in this
// match result's pattern.
System.out.println(
"The number of capturing groups is equal to: "
+ myResult.groupCount());
}
}
}
The number of capturing groups is equal to: 3