Guía para la clase StringUtils de Apache Commons en Java

     

    Introducción

    los Apache Commons La biblioteca proporciona muchas interfaces, implementaciones y clases nuevas que se expanden en el marco principal de Java. Es una de las principales bibliotecas de terceros y está presente en muchos proyectos.

    En este artículo, hemos compilado una Guía para la clase StringUtils de Apache Commons, que proporciona algunas utilidades y herramientas muy buenas para trabajar con Strings, ampliando la funcionalidad de la clase principal: java.lang.String.

    StringUtils es probablemente la clase más utilizada de Apache Commons, y contiene varios métodos de utilidad y conveniencia que permiten a los desarrolladores evitar escribir código repetitivo o simplemente complicado código para operaciones básicas.

    ¿Por qué utilizar StringUtils en lugar de String Methods?

    Muchos de los métodos del StringUtils clase tienen sus equivalentes en el java.lang.String, pero los que se encuentran en StringUtils son nulo seguro. Esto significa que NullPointerExceptionLos mensajes de correo electrónico no se lanzan en casos en los que no se espera que lo hagan.

    Como se mencionó anteriormente, Apache Commons contiene varios métodos, y cubriremos algunos de los más utilizados:

    • StringUtils.isEmpty () y StringUtils.isBlank ()
    • StringUtils.equals ()
    • StringUtils.compare ()
    • StringUtils.indexOf ()
    • StringUtils.lastIndexOf ()
    • StringUtils.contains ()
    • StringUtils.containsIgnoreCase ()
    • StringUtils.containsAny ()
    • StringUtils.containsNone ()
    • StringUtils.containsOnly ()
    • StringUtils.substring ()
    • StringUtils.split ()
    • StringUtils.join ()
    • StringUtils.remove ()
    • StringUtils.replace ()
    • StringUtils.countMatches ()

    Introducción a Apache Commons

    Para poder utilizar la biblioteca Apache Commons, primero debemos importarla a nuestro proyecto.

    Si está utilizando Maven, importe el última dependencia para usted pom.xml archivo:

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

    Alternativamente, si está usando Gradle:

    compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.11'

    Con el commons-lang3 dependencia en nuestro proyecto, podemos pasar a discutir algunos de los métodos más utilizados de StringUtils. ¡Empecemos!

    Comparación de cadenas con Apache Commons

    Comparar cadenas, comprobar si están vacías o en blanco, o simplemente comprobar si son iguales son operaciones bastante comunes.

    Comencemos con algunos métodos relacionados con la comparación.

    StringUtils.isEmpty () y StringUtils.isBlank ()

    Estos dos métodos se explican por sí mismos: ambos se utilizan para comprobar si String contiene cualquier texto. Ambos regresan true Si el String de hecho está vacío. Adicionalmente, isBlank() también regresará true si un String contiene solo espacios en blanco.

    Te puede interesar:Eliminar elemento de una matriz en Java

    También tienen sus métodos inversos: isNotEmpty() y isNotBlank().

    Veamos cómo podemos usar isEmpty() junto a su contraparte java.lang.String.isEmpty(), tanto como isBlank():

    String nullString = null;
String emptyString = "";
String blankString = "n t   n";

if(!nullString.isEmpty()) {
    System.out.println("nullString isn't null");
}

if(StringUtils.isEmpty(emptyString)) {
    System.out.println("emptyString is empty");
}

if(StringUtils.isBlank(blankString)) {
    System.out.println("blankString is blank");
}

    Tenemos tres cadenas aquí. Uno apunta a null, el segundo no es nulo, pero no tiene ningún contenido (está vacío), y el tercero no está vacío, pero producirá un resultado en blanco si se imprime.

    Ejecutar este código da como resultado:

    Exception in thread "main" java.lang.NullPointerException

    los isEmpty() método que está integrado en java.lang.String no es seguro para nulos. Lanzará un NullPointerException si intenta comprobar si está vacío, ya que está llamando a un método en un null referencia. Deberá verificar si la referencia es nula de antemano:

    String nullString = null;
String emptyString = "";
String blankString = "n t   n";

if(nullString != null && !nullString.isEmpty()) {
    System.out.println("nullString isn't null");
}

if(StringUtils.isEmpty(emptyString)) {
    System.out.println("emptyString is empty");
}

if(StringUtils.isBlank(blankString)) {
    System.out.println("blankString is blank");
}

    Ahora, esto resulta en:

    emptyString is empty
blankString is blank

    Y si probamos estos métodos en el nullString:

    if(StringUtils.isEmpty(nullString)) {
    System.out.println("emptyString is empty");
}

if(StringUtils.isBlank(nullString)) {
    System.out.println("blankString is blank");
}

    Esto resulta en:

    emptyString is empty
blankString is blank

    StringUtils Los métodos son seguros para nulos y producen el resultado que esperaría que estos métodos devolvieran al encontrar un null referencia.

    StringUtils.equals ()

    Este hace exactamente lo que crees que hace: compara dos cadenas y devuelve true, si son idénticas o ambas referencias apuntan a null, pero tenga en cuenta que este método es distingue mayúsculas y minúsculas.

    Veamos cómo funciona este método:

    System.out.println(StringUtils.equals(null, null));
System.out.println(StringUtils.equals(null, "some string"));
System.out.println(StringUtils.equals("some string", null));
System.out.println(StringUtils.equals("some string", "some string"));
System.out.println(StringUtils.equals("some other string", "some string"));

    Esto dará como resultado:

    true
false
false
true
false

    Por el simple hecho de comparar el equals() método de StringUtils al java.lang.String.equals(), probémoslos:

    String nullString = null;

System.out.println(StringUtils.equals(nullString, null));
System.out.println(StringUtils.equals(nullString, "string"));

System.out.println(nullString.equals(null));
System.out.println(nullString.equals("string"));

    Esto resulta en:

    Te puede interesar:Cómo dividir una cadena en Java
     
    true
false
Exception in thread "main" java.lang.NullPointerException

    Nuevamente, invocando un método en un null resultados de referencia en un NullPointerException, tendríamos que comprobar si la variable de referencia es null antes de usarlo.

    StringUtils.compare ()

    La declaración de este método es la siguiente:

    public static int compare(CharSequence str1, CharSequence str2)

    Este método compara dos Strings lexicográficamente, de la misma manera java.lang.String.compareTo() hace, regresando:

    • 0 Si str1 es igual a str2 (o ambos son null)
    • Un valor menor que 0 Si str1 es menos que str2
    • Un valor mayor que 0 Si str1 es mayor que str2

    En este artículo no discutiremos qué es exactamente comparar dos Strings lexicográficamente significa, así que si está interesado en leer más sobre eso, consulte esta enlace.

    Ahora, veamos cómo podemos usarlo en nuestro programa:

    System.out.println(StringUtils.compare(null, null));
System.out.println(StringUtils.compare(null , "a"));
System.out.println(StringUtils.compare("a", null));
System.out.println(StringUtils.compare("a", "A"));
System.out.println(StringUtils.compare("a", "a"));

    Esto a su vez generará:

    0
-1
1
32
0

    No hay té null El valor se considera menor que un valor nonull valor. Dos null los valores se consideran iguales.

    Indexación de secuencias de búsqueda con Apache Commons

    Ahora, echemos un vistazo a un grupo de métodos que se ocupan de las comprobaciones de índices, por supuesto, nulo seguro camino. Todos estos métodos tienen múltiples variantes sobrecargadas, pero las más generales son:

    public static int indexOf(CharSequence seq, CharSequence searchSeq)
public static int lastIndexOf(CharSequence seq, CharSequence searchSeq)
public static boolean contains(CharSequence seq, CharSequence searchSeq)

    Hay una cosa que todos tienen en común: todos usan susnull variantes seguras de java.lang.String si es posible hacerlo. Expliquemos esto con un poco más de detalle.

    StringUtils.indexOf ()

    Este método, al igual que el integrado, buscará el índice de la primera aparición de una secuencia dentro de otra secuencia. Si el incorporado java.lang.String.indexOf() el método no produce un NullPointerException, se utilizará. Si no, la implementación de Apache Commons se hace cargo.

    El valor de retorno es el primer índice encontrado, o -1 si no hay coincidencia o la cadena de entrada es null.

    Escribamos un código ahora:

    String s = "Java is a general-purpose programming language";

System.out.println(StringUtils.indexOf(null, "a"));
System.out.println(StringUtils.indexOf(s, "general"));
System.out.println(StringUtils.indexOf(s, "l"));
System.out.println(StringUtils.indexOf(s, "lan"));

    Ejecutar el código anterior dará como resultado el siguiente resultado:

    -1
10
16
38

    StringUtils.lastIndexOf ()

    los lastIndexOf() El método funciona de la misma manera indexOf() funciona, pero devuelve la última aparición, no la primera de la secuencia de búsqueda.

    Te puede interesar:Java: encontrar elementos duplicados en una secuencia

    Ejecutemos el mismo código de antes:

    String s = "Java is a general-purpose programming language";

System.out.println(StringUtils.lastIndexOf(null, "a"));
System.out.println(StringUtils.lastIndexOf(s, "general"));
System.out.println(StringUtils.lastIndexOf(s, "l"));
System.out.println(StringUtils.lastIndexOf(s, "lan"));

    Ejecutar el código anterior dará como resultado el siguiente resultado:

    -1
10
38
38

    Compruebe si la cadena contiene otra cadena con Apache Commons

    StringUtils.contains ()

    los contains() devuelve el método true o false basado en si una secuencia de búsqueda está contenida dentro de otra secuencia o no.

    Si tiene éxito, este método también utiliza el java.lang.String.indexOf(String). En el caso de null como entrada, false es regresado:

    String s = "Java is a general-purpose programming language";

System.out.println(StringUtils.contains(null, "a"));
System.out.println(StringUtils.contains(s, "Java"));
System.out.println(StringUtils.contains(s, "Python"));
System.out.println(StringUtils.contains(s, "pRoGrAmMinG"));

    El método, por supuesto, si distingue entre mayúsculas y minúsculas, por lo que la última llamada también devolverá false:

    false
true
false
false

    StringUtils.containsIgnoreCase ()

    los containsIgnoreCase() El método funciona de la misma manera contains() el método lo hace, pero no distingue entre mayúsculas y minúsculas:

    String s = "Java is a general-purpose programming language";

System.out.println(StringUtils.containsIgnoreCase(null, "a"));
System.out.println(StringUtils.containsIgnoreCase(s, "Java"));
System.out.println(StringUtils.containsIgnoreCase(s, "Python"));
System.out.println(StringUtils.containsIgnoreCase(s, "pRoGrAmMinG"));

    Esto resulta en:

    false
true
false
true

    StringUtils.containsAny ()

    los containsAny() la verificación del método acepta un vararg, además del String en el que estamos buscando. true si la secuencia buscada contiene algún elemento del vararg:

    String s = "Java is a general-purpose programming language";

System.out.println(StringUtils.containsAny(s, "general", "python", "something", "javascript"));

    Esto resulta en:

    true

    Este método también distingue entre mayúsculas y minúsculas, así que asegúrese de tenerlo en cuenta.

    StringUtils.containsNone ()

    En lugar de hacer casos extremos con el método anterior, simplemente puede usar containsNone() si desea asegurarse de que una cadena no contenga ninguno de los elementos que ingresó como vararg:

    String s = "Java is a general-purpose programming language";

System.out.println(StringUtils.containsNone(s, "general", "python", "something", "javascript"));

    Esto resulta en:

    false

    StringUtils.containsOnly ()

    O, si desea verificar si una cadena contiene solo el contenido que predefinió, puede usar el containsOnly() método:

    String s = "Java";

System.out.println(StringUtils.containsOnly(s, "Java"));

    Esto resulta en:

    Te puede interesar:Java: compruebe si la cadena es un número
     
    true

    Métodos de subcadena de Apache Commons

    StringUtils.substring ()

    Entre muchas de las variantes sobrecargadas disponibles de este método, discutiremos dos de ellas:

    • substring(String str, int start)
    • substring(String str, int start, int end)

    Este método devuelve una subcadena que comienza en el start yendo al final de la String, o la end índice.

    También podemos usar un número negativo para start parámetro, que nos dará una subcadena que comienza n personajes del final del String.

    Si hay un null entrada, el valor devuelto simplemente será null.

    Veamos cómo podemos usarlo:

    System.out.println(StringUtils.substring("a random string", 4, 8));
System.out.println(StringUtils.substring("a random string", -7));
System.out.println(StringUtils.substring(null, 5));

    Ejecutar el código anterior nos da:

    ndom
 string
null

    StringUtils.split ()

    Provisto de un String y un carácter separador, este método dividirá el String y colóquelo en una matriz.

    Los elementos de la matriz resultante son subcadenas que están delimitadas por separadores en el original. String. El separador no se incluye en la matriz final después de la división.

    Al igual que con los otros métodos en el StringUtils, vuelve null si la entrada es null.

    Veamos algo de código y cómo funciona este método:

    String csvString = "Id, Name, Age, Location";
    	
System.out.println(Arrays.toString(StringUtils.split(csvString, ',')));
System.out.println(Arrays.toString(StringUtils.split(null, '.')));
System.out.println(Arrays.toString(StringUtils.split("", '.')));

    Después de ejecutar el código, obtenemos:

    [Id,  Name,  Age,  Location]
null
[]

    StringUtils.join ()

    Este método representa el opuesto directo del split() método.

    Después de dividir un String con un carácter separador, podemos unirlo fácilmente con el join() método, proporcionando una lista o una matriz de elementos. Devuelve un String creado pegando los elementos proporcionados juntos usando el separador. Si la entrada es null, el método devuelve null.

    Veamos este ejemplo básico:

    Te puede interesar:Configurar el registro cerrado para proyectos Spring Boot con Github y Jenkins
     
    String csvString = "Id, Name, Age, Location";
    	
String[] myStr =  StringUtils.split(csvString, ',');
System.out.println(StringUtils.join(myStr, ';'));

    Ejecutar el código anterior nos da:

    Id; Name; Age; Location

    StringUtils.remove ()

    Hay dos variantes de este método que queremos ver:

    public static String remove(String str, char remove)
public static String remove(String str, String remove)

    Ambos hacen lo mismo, con la excepción de que el segundo elimina cada ocurrencia de un subcadena, mientras que el primero elimina toda aparición de un personaje de lo dado String str.

    Si la entrada es null, el método devuelve null.

    Para este, dividiremos los ejemplos en dos bloques de código separados, porque puede ser un poco difícil diferenciarlos a primera vista. Empecemos con remove(String str, char remove):

    System.out.println(StringUtils.remove(null, 'a'));
System.out.println(StringUtils.remove("", 'a'));
System.out.println(StringUtils.remove("queued", 'u'));

System.out.println(StringUtils.remove(null, "abc"));
System.out.println(StringUtils.remove("", "abc"));
System.out.println(StringUtils.remove("abc", null));
System.out.println(StringUtils.remove("queued", "ue"));

    Ejecutemos esto y veamos qué produce:

    null // Returned null
     // Removed 'a' from ""
qeed // Removed 'u' characters
null // Returned null
     // Removed "abc" from ""
abc  // Removed null from "abc"
qd   // Removed "ue" from "queued"

    Debemos señalar una cosa aquí, ya que se puede pasar por alto fácilmente: cuando el remove el parámetro tiene un null valor, se devuelve la cadena de origen.

    StringUtils.replace ()

    Como la mayoría de los métodos que hemos cubierto, este también se explica por sí mismo: busca un String Dentro de un String, lo encuentra si existe y reemplaza todas sus ocurrencias con un nuevo String.

    La declaración de este método es la siguiente:

    public static String replace(String text, String searchString, String replacement)

    Si el searchString no se encuentra dentro text, no pasa nada, y nuestro text Sigue igual. Siguiendo la misma lógica, si text es null, este método devuelve null.

    Si alguno de searchString o replacement tener el valor de null, el método devuelve su fuente, es decir text.

    Probemos este método:

    String string = "a simple sentence";
System.out.println(StringUtils.replace(string, "simple", "complicated"));

    Esto resultará en:

    a complicated sentence

    StringUtils.countMatches ()

    countMatches() cuenta cuántas veces aparece un carácter especificado (o una subcadena) dentro de la Cadena dada. UN null o una entrada vacía regresa 0.

    Te puede interesar:Java: compruebe si la cadena comienza con otra cadena

    Veamos cómo funciona esto en código:

    String string = "I'm blue Da ba dee da ba di, Da ba dee da ba di";

System.out.println(StringUtils.countMatches(null, 'd'));
System.out.println(StringUtils.countMatches(string, 'd'));

System.out.println(StringUtils.countMatches(null, "da"));
System.out.println(StringUtils.countMatches(string, "da"));

    Ejecutar el código anterior nos da:

    0
6
0
2

    Conclusión

    En este artículo, hemos cubierto algunos de los métodos más utilizados y conocidos dentro del Apache Commons ‘ StringUtils clase.

    Los métodos encontrados en el StringUtils class son seguros para nulos y proporcionan funcionalidad básica y extendida a los métodos String incorporados.

     

    Rate this post

    Etiquetas: