Java: compruebe si la cadena comienza con otra cadena

    Introducción

    En este artículo, veremos cómo verificar si una cadena comienza con otra cadena en Java.

    Esta es una tarea bastante común en programación y es muy similar a verificar si una cadena contiene una subcadena. Por ejemplo, esto puede resultar útil si queremos filtrar todas las palabras de una gran selección que comienza con una Cadena específica.

    Sin embargo, este problema difiere de verificar si una cadena solo contiene una subcadena específica, y hay algunas formas de hacerlo tanto en Core Java como en Apache Commons:

    • String.startsWith ()
    • Stream.anyMatch ()
    • String.indexOf ()
    • Patrón con Regex
    • Usando un bucle for
    • StringUtils.indexOf ()
    • StringUtils.startsWith ()
    • StringUtils.startsWithAny ()
    • StringUtils.startsWithIgnoreCase ()

    Core Java

    Comencemos con soluciones que se pueden implementar fácilmente con Core Java.

    String.startsWith ()

    Este método hace exactamente lo que necesitamos que haga, y es la forma más común de resolver este problema. Devuelve un boolean, que indica si la cadena comienza con la palabra clave proporcionada:

    String string = "every end is a new beginning";

System.out.println(string.toLowerCase().startsWith("new".toLowerCase()));
System.out.println(string.toLowerCase().startsWith("EVERY".toLowerCase()));
System.out.println(string.toLowerCase().startsWith(""));

    Ejecutando estas salidas:

    false
true
true

    Nota: Si el parámetro pasado es una cadena vacía, el resultado siempre es true.

    Te puede interesar:Cómo formatear el número como cadena de moneda en Java

    Por supuesto, este método es distingue mayúsculas y minúsculas, y siempre debe usarse junto con toLowerCase() o toUpperCase() cuando solo buscamos una palabra clave específica y no nos importa si los casos coinciden.

    Stream.anyMatch ()

    Otra cosa que podríamos comprobar es si una cadena comienza con varias subcadenas. Digamos, tenemos algunos prefijos estandarizados; podemos usar make a Stream de subcadenas y ejecutar un anyMatch() compruebe la cadena que estamos registrando.

    Echemos un vistazo a cómo hacer eso:

    String string = "every end is a new beginning";
System.out.println(Stream.of("every", "none").anyMatch(string::startsWith));

    Aquí, hemos creado un Stream de posibles subcadenas, y verificó si alguna de ellas está presente al comienzo de la Cadena dada con una llamada de referencia de método a startsWith().

    Este código da como resultado:

    true

    String.indexOf ()

    los indexOf() El método puede ser bastante útil para resolver una variedad de problemas relacionados con subcadenas, incluida la verificación de si una cadena comienza con una específica.

    El método devuelve el índice de la primera aparición de una subcadena dentro de una cadena si se encuentra, de lo contrario -1.

    Te puede interesar:Java 8 – Ejemplos de Stream.map ()

    Tiene algunas variantes sobrecargadas de las que solo necesitaremos la siguiente, ya que las otras tienen diferentes dispositivos:

    public int indexOf(String str)

    Si el indexOf() devuelve el método 0, eso significa que nuestro String comienza con otro que le hemos dado como parámetro.

    Por ejemplo:

    String string = "Just a sample String";

System.out.println(string.toLowerCase().indexOf("just".toLowerCase()));
System.out.println(string.toLowerCase().indexOf("String".toLowerCase()));
System.out.println(string.toLowerCase().indexOf("something else".toLowerCase()));

    dará salida:

    0
14
-1
    • La respuesta que estamos buscando se encuentra en nuestro primer ejemplo, ya que devolvió 0 – exactamente lo que necesitamos, lo que significa que nuestra cadena comienza con un parámetro dado.
    • Podemos ver claramente que en el segundo ejemplo, el "String" El parámetro que hemos dado se encuentra de hecho dentro de nuestra Cadena, pero en la posición 14, que no es lo que estábamos buscando.
    • El tercer ejemplo ni siquiera está contenido en nuestro String y devuelve -1.

    Usando la información anterior, podemos acumular la lógica en una función:

    public static boolean startsWithSubstring(String text, String keyword) {
    return text.toLowerCase().indexOf(keyword.toLowerCase()) == 0;
}

    Patrón con Regex y Matcher

    los Pattern class es una representación compilada de una expresión regular. Con este Pattern entonces podemos generar un motor que reconoce dicha expresión regular – podemos generar un Matcher.

    Te puede interesar:Cómo formatear una cadena en Java con ejemplos

    Usaremos el find() método en combinación con start() para comprobar si nuestro Matcher instancia comienza con una cadena determinada:

    public static boolean startsWithSubstring(String text, String keyword) {
    String inputString = text.toLowerCase();
    String subString = keyword.toLowerCase();


    // We compile the regular expression to generate a Pattern object
    Pattern pattern = Pattern.compile(subString);

    // Then we generate an engine (Matcher) which can be used
    // to recognize and match the regular expression it was
    // generated from (in our case "this").
    Matcher matcher = pattern.matcher(inputString);

    // find() compares the assigned and compiled patterns, and will return a boolean value indicating if they match.
    // That's where the start() method comes into play; it returns the index of the position 
    // where the two strings matched, or -1 if it's not found.
    if (matcher.find()) {
          return matcher.start() == 0;
    }
    return false;
}

    Probemos este método:

    System.out.println(startsWithSubstring(string, "every"));

    Esto resulta en:

    true

    Usando un bucle for

    Una forma más sencilla de resolver este problema sería utilizar un bucle for.

    Repetimos toda la longitud de la cadena de búsqueda, comparamos la primera searchString.length() personajes y regreso true si todo coincide.

    Veamos cómo funciona todo esto en código:

    public static boolean startsWithSubstring(String text, String keyword) {
    for (int i = 0; i < keyword.length(); i++) {
          if (text.toLowerCase().charAt(i) != keyword.toLowerCase().charAt(i)) {
              System.out.println("String doesn't start with " + """ + keyword + """);
        return false;
          } else if (i == keyword.length() - 1) {
              System.out.println("String starts with " + """ + keyword + """);
              return true;
          }
    }
    return false;
}

    Probemos este método:

    Te puede interesar:Guía de JPA con Hibernate: Mapeo básico
     
    String string = "Just a sample String";

System.out.println(startsWithSubstring(string, "just"));
System.out.println(startsWithSubstring(string, "String"));
System.out.println(startsWithSubstring(string, "something else"));

    Esto resulta en:

    String starts with "just"
true
String doesn't start with "String"
false
String doesn't start with "something else"
false

    Por defecto, si no hubiéramos usado toLowerCase() para igualar las letras en el método en sí, este enfoque habría sido sensible a mayúsculas y minúsculas.

    Apache Commons

    los Apache Commons La biblioteca proporciona una funcionalidad que se expande en el marco principal de Java. Es una de las principales bibliotecas de terceros y está presente en muchos proyectos Java modernos.

    Apache Commons ofrece la StringUtils class, que contiene muchos métodos utilizados para manipular cadenas. La mayoría de estos métodos son bastante similares a los que se encuentran en java.lang.String. La principal diferencia es que todos los métodos dentro del StringUtils clase son nulo seguro.

    Sin embargo, para esta tarea solo necesitaremos algunos métodos de esta clase:

    • .indexOf()
    • .startsWith()
    • .startsWithIgnoreCase().

    Si aún no lo ha hecho, incluya la biblioteca Apache Commons en su proyecto agregando una dependencia a su pom.xml file si estás usando Maven:

    <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>

    O agregándolo a Gradle:

    Te puede interesar:Diferencia entre ArrayList y LinkedList en Java: código y rendimiento
     
    compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.11'

    StringUtils.indexOf ()

    Este método tiene algunas variantes sobrecargadas, todas las cuales devuelven un int valor que indica el índice de la primera aparición de la subcadena, o -1 si la subcadena no aparece en absoluto.

    Nos centraremos en la siguiente variante de este método:

    public static int indexOf(CharSequence seq, CharSequence searchSeq)

    Este método toma dos Strings /CharSequences.

    los seq El parámetro representa la cadena en la que buscaremos para encontrar searchSeq. Se aplica la misma lógica que antes, si esta función regresa 0, sabremos que nuestra cadena comienza con un dato searchSeq subcadena.

    También tenga en cuenta que este método, al igual que su contraparte, también distingue entre mayúsculas y minúsculas, por lo que .toLowerCase() o .toUpperCase() es necesario para lograr un comportamiento que no distinga entre mayúsculas y minúsculas.

    Usar este método es muy similar a usar el indexOf() desde java.lang.String:

    String string = "a simple string to search in";

System.out.println(StringUtils.indexOf(string.toLowerCase(), "a simple".toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), "string".toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), "something".toLowerCase()));

    Esto producirá:

    Te puede interesar:Cómo convertir una matriz de Java a ArrayList
     
    0
9
-1

    Y así, podemos usar esto como un método de conveniencia:

    public static boolean startsWithSubstring(String text, String keyword) {
    return StringUtils.indexOf(text.toLowerCase(), keyword.toLowerCase()) == 0;
}

    StringUtils.startsWith ()

    Este método hace exactamente lo que esperas. También distingue entre mayúsculas y minúsculas, como sus predecesores, y acepta los mismos dos parámetros.

    Vuelve true Si el text comienza con el keywordo false si no es así.

    Comparando dos null los valores resultarán en true:

    String string = "a simple string to search in";

System.out.println(StringUtils.startsWith(string.toLowerCase(), "A SIMPLE"));
System.out.println(StringUtils.startsWith(string.toLowerCase(), "A SIMPLE".toLowerCase()));
System.out.println(StringUtils.startsWith(null, null));

    Ejecutar esto dará como resultado:

    false
true
true

    StringUtils.startsWithAny ()

    los startsWithAny() no tiene una contraparte en el java.lang.String clase, y es exclusivo de StringUtils.

    Sin embargo, está muy cerca de lo que hicimos con anyMatch() en una secuencia: comprueba si un String comienza con cualquiera de las subcadenas dadas, volviendo true o false adecuadamente.

    Te puede interesar:Comparando cadenas con Java

    También distingue entre mayúsculas y minúsculas:

    String string = "a simple string to search in";

System.out.println(StringUtils.startsWithAny(string, "something", "a simple"));
System.out.println(StringUtils.startsWithAny(string, "something", "string"));
System.out.println(StringUtils.startsWithAny(string, "something", null));
System.out.println(StringUtils.startsWithAny(string, "something", ""));

    Ejecutar esto nos da:

    true
false
false
true

    StringUtils.startsWithIgnoreCase ()

    Ya que puede resultar molesto llamar toLowerCase() todo el tiempo en Strings durante la comparación, alternativamente puede demandar al startsWithIgnoreCase() método.

    Como el startsWith() método de la misma clase, toma dos cadenas (o CharSequence) tipos, y el valor de retorno es true o false dependiendo de si el texto realmente comienza con la palabra clave proporcionada:

    String string = "a simple string to search in";

System.out.println(StringUtils.startsWithIgnoreCase(string, "something"));
System.out.println(StringUtils.startsWithIgnoreCase(string, "A SIMPLE"));
System.out.println(StringUtils.startsWithIgnoreCase(string, ""));
System.out.println(StringUtils.startsWithIgnoreCase(string, null));

    Ejecutando estas salidas:

    false
true
true
false

    Conclusión

    En este artículo, hemos repasado todos los diferentes métodos para verificar si un String comienza con otro String, tanto en el núcleo de Java como utilizando la biblioteca Apache Commons.

    En conclusión, hay muchas formas diferentes de realizar esta tarea. En realidad, podríamos haber combinado cualquiera de los métodos anteriores para encontrar un índice en el que comience una subcadena y, a partir de ahí, verificar dónde está posicionada la subcadena.

    Te puede interesar:AWS S3 con Java: carga de archivos, creación y eliminación de buckets de S3

    La mayoría de las veces, solo con el startsWith() métodos, o startsWithIgnoreCase() sería suficiente para resolver este problema y también proporcionaría el código más limpio y corto.

     

    Rate this post

    Etiquetas: