Clase StringUtils de Apache Commons

Introducción a StringUtils

StringUtils es la clase de Apache Commons más utilizada. Contiene varias utilidades y métodos que ayudan a los desarrolladores a evitar escribir código repetitivo o simplemente difícil de manejar para operaciones básicas.

Muchos de los métodos de la clase StringUtils tienen sus equivalentes java.lang.String pero, a diferencia de los métodos java.lang.String , son seguros para nulos. Esto significa que no se lanza una NullPointerException en el momento más inesperado.

Apache Commons contiene una serie de métodos y veremos algunos de los más utilizados.

Lista de métodos StringUtils:

StringUtils.isEmpty() y StringUtils.isBlank()

Ambos métodos se utilizan para verificar si una cadena contiene texto. Devuelven verdadero si la cadena está realmente vacía. Además, isBlank() también devolverá verdadero si la cadena solo contiene espacios.

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

Veamos cómo puedes usar isEmpty() junto con su equivalente java.lang.String.isEmpty() , así como isBlank() :

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

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

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

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

Hay tres variables de tipo String aquí . Uno apunta a nulo , el segundo no es nulo pero no tiene contenido (una cadena vacía) y el tercero no está vacío pero imprimirá un resultado vacío.

Ejecutar este código da como resultado:

emptyValue is emptyValue
blankValue is blankValue
Exception in thread "main" java.lang.NullPointerException

El método isEmpty() integrado en java.lang.String no es seguro para nulos . Obtendrá fácilmente una NullPointerException si intenta verificar si está vacío, porque llama al método en una referencia nula . Será necesario comprobar previamente si la referencia es nula:

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

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

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

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

Ahora esto da como resultado:

emptyValue is emptyValue
blankValue is blankValue

Y si probamos estos métodos encadena nula:

String nullValue = null;

if(StringUtils.isEmpty(nullValue)) {
   System.out.println("nullValue is emptyValue");
}

if(StringUtils.isBlank(nullValue)) {
   System.out.println("nullValue is blankValue");
}

Entonces obtenemos:

nullValue is emptyValue
nullValue is blankValue

Los métodos StringUtils son seguros para nulos y producen el resultado esperado incluso si se pasan nulos .

StringUtils.equals()

Este método compara dos cadenas y devuelve verdadero si son idénticas o si ambas referencias apuntan a nulo , pero tenga en cuenta que este método distingue entre mayúsculas y minúsculas.

Vamos a ver cómo funciona:

System.out.println(StringUtils.equals(null, null));
System.out.println(StringUtils.equals(null, "some information"));
System.out.println(StringUtils.equals("some information", null));
System.out.println(StringUtils.equals("some information",  "some information"));
System.out.println(StringUtils.equals("some additional information", "some information"));

Resultado:

true
false
false
true
false

Para comparar el método equals() de StringUtils con java.lang.String.equals() :

String nullValue = null;

System.out.println(StringUtils.equals(nullValue, null));
System.out.println(StringUtils.equals(nullValue, "some information"));

System.out.println(nullValue.equals(null));
System.out.println(nullValue.equals("some information"));

Esto te lleva de vuelta a:

true
false
Exception in thread "main" java.lang.NullPointerException

Nuevamente, llamar a un método en una referencia nula da como resultado una NullPointerException , y deberá verificar si la variable de referencia es nula antes de usarla.

StringUtils.comparar()

La declaración de este método se ve así:

public static int compare(final String str1, final String str2)

Este método compara dos cadenas lexicográficamente, como lo hace el método java.lang.String.compareTo() , devolviendo:

• 0 si str1 es igual a str2 (o ambos son nulos)
• El valor es menor que 0 si str1 es menor que str2
• Valor mayor que 0 si str1 es mayor que str2

El orden lexicográfico es el orden del diccionario. Veamos cómo podemos usar esto en nuestro programa:

System.out.println(StringUtils.compare(null, null));
System.out.println(StringUtils.compare(null , "codeGym"));
System.out.println(StringUtils.compare("codeGym", null));
System.out.println(StringUtils.compare("codeGym", "CODEGYM"));
System.out.println(StringUtils.compare("codeGym", "codeGym"));

Obtenemos:

0
-1
1
32
0

Nota: un valor nulo se considera menor que un valor no nulo . Dos valores nulos se consideran iguales.

Comprobando si una cadena contiene otra subcadena

Para hacer esto, StringUtils tiene 5 métodos:

• contiene()
• contieneIgnorarCaso()
• contieneCualquiera()
• contiene Ninguno()
• contiene solo ()

El método contains() devuelve verdadero o falso dependiendo de si la secuencia de búsqueda está contenida en otra secuencia o no.

Si se pasa nulo a dicho método , devolverá falso . Si se pasa un valor no nulo , el método simplemente llamará a java.lang.String.indexOf(String str) en el objeto pasado.

Ejemplos:

String value = "CodeGym is cool";

System.out.println(StringUtils.contains(null, "a"));
System.out.println(StringUtils.contains(value, "CodeGym"));
System.out.println(StringUtils.contains(value, "C++"));
System.out.println(StringUtils.contains(value, "codegym"));

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

false
true
false
false

El método containsAny() devuelve verdadero si la cadena pasada como primer argumento contiene al menos una de las subcadenas pasadas en los argumentos 2-N.

Ejemplo:

String value = "CodeGym is cool";
System.out.println(StringUtils.containsAny(value, "cool", "c00l", "bro", "hello"));

Mostrará:

true

Este método también distingue entre mayúsculas y minúsculas.

método contieneNone()

Cuando necesite comprobar que una determinada cadena no contiene nada de la lista, puede utilizar el método containsNone() . El primer parámetro es una cadena y los siguientes parámetros son cadenas que no deben estar en el receptor de destino.

Ejemplo:

String s = "CodeGym is cool";
System.out.println(StringUtils.containsNone(s, 'g', 'a'));

Salida de la consola:

false

Trabajando con subcadenas

Trabajar con subcadenas es similar a trabajar con métodos de la clase String :

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

Estos métodos devuelven una subcadena de la cadena str . La cadena está dada por dos índices: inicio y fin . Y como es habitual en Java, el último carácter del rango es end-1 . ¿Cuál es la ventaja de estos métodos?

Si pasa nulo a dicho método , simplemente devolverá nulo en lugar de lanzar una excepción. Estos métodos admiten valores de índice negativos. En este caso, la cadena se considera como un bucle cerrado. El último carácter es seguido por el primero, y así sucesivamente.

Veamos cómo podemos usarlo:

System.out.println(StringUtils.substring("lets java", 2, 6));
System.out.println(StringUtils.substring("lets java", -8));
System.out.println(StringUtils.substring(null, 3));

Ejecutar el código anterior nos da:

ts j
ets java
null

StringUtils.split()

Un método que le permite dividir una cadena en subcadenas utilizando un carácter delimitador especial. Si hay uno en la cadena de destino, el método devolverá una matriz de subcadenas. Si no hay ningún carácter, se devolverá una matriz vacía. Bueno, si se pasa nulo al método , devolverá nulo . Echemos un vistazo a este código y cómo funciona el método:

String myData = "Address, City, State, Zip, Phone, Email, Password";

System.out.println(Arrays.toString(StringUtils.split(myData, ',')));
System.out.println(Arrays.toString(StringUtils.split(null, '.')));
System.out.println(Arrays.toString(StringUtils.split("", '.')));

Resultado:

[Address,  City,  State,  Zip,  Phone,  Email,  Password]
null
[]

StringUtils.unirse()

El método join() le permite concatenar una matriz de cadenas en una sola cadena. Al mismo tiempo, se le puede pasar un carácter separador especial, que se agregará entre subcadenas en la cadena resultante. Y si se pasa nulo al método , devolverá nulo .

Este método es exactamente lo contrario del método split() . Veamos este sencillo ejemplo:

String myData = "Address, City, State, Zip, Phone, Email, Password";

String[] myString =  StringUtils.split(myData, ',');
System.out.println(StringUtils.join(myString, '-'));

Ejecutar el código anterior nos da:

Address- City- State- Zip- Phone- Email- Password

StringUtils.reemplazar()

Busca una cadena dentro de una cadena, la encuentra si existe y reemplaza todas las apariciones de la misma con una nueva cadena.

La declaración de este método se ve así:

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

Si la cadena de búsqueda no se encuentra en el texto, no pasará nada y el texto seguirá siendo el mismo. Siguiendo la misma lógica, si el texto es nulo , este método devuelve nulo . Si busca una cadena nula o reemplaza una subcadena con nula , el método devolverá la cadena original.

Probemos este método:

String value = "CodeGym is the best";
System.out.println(StringUtils.replace(value, "best", "cool"));

Resultado:

CodeGym is the cool

• Guía de la clase StringUtils de Apache Commons en Java
• Guía de clases de Apache Commons Java StringUtils