Classe StringUtils do Apache Commons

Introdução ao StringUtils

StringUtils é a classe Apache Commons mais usada. Ele contém vários utilitários e métodos que ajudam os desenvolvedores a evitar escrever clichê ou simplesmente código pesado para operações básicas.

Muitos dos métodos na classe StringUtils têm seus equivalentes java.lang.String , mas, ao contrário dos métodos java.lang.String , são seguros para valores nulos. Isso significa que um NullPointerException não é lançado no momento mais inesperado.

O Apache Commons contém vários métodos e veremos alguns dos mais usados.

Lista de métodos StringUtils:

StringUtils.isEmpty() e StringUtils.isBlank()

Ambos os métodos são usados ​​para verificar se uma string contém algum texto. Eles retornam true se a string estiver realmente vazia. Além disso, isBlank() também retornará true se a string contiver apenas espaços.

Eles também têm seus próprios métodos inversos: isNotEmpty() e isNotBlank() .

Vamos ver como você pode usar isEmpty() junto com sua contraparte java.lang.String.isEmpty() , bem 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");
}

Existem três variáveis ​​do tipo String aqui . Um aponta para null , o segundo não é nulo , mas não tem conteúdo (uma string vazia) e o terceiro não está vazio, mas imprimirá um resultado vazio.

A execução desse código resulta em:

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

O método isEmpty() embutido em java.lang.String não é seguro para valores nulos . Você obterá facilmente um NullPointerException se tentar verificar se está vazio, porque você chama o método em uma referência nula . Será necessário verificar antecipadamente se a referência é 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");
}

Agora isso resulta em:

emptyValue is emptyValue
blankValue is blankValue

E se testarmos esses métodos emnullString:

String nullValue = null;

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

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

Então obtemos:

nullValue is emptyValue
nullValue is blankValue

Os métodos StringUtils são null safe e produzem o resultado esperado mesmo se forem passados ​​null .

StringUtils.iguals()

Este método compara duas strings e retorna true se forem idênticas ou se ambas as referências apontarem para null , mas esteja ciente de que este método diferencia maiúsculas de minúsculas.

Vamos ver como isso 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 o método equals() de StringUtils com 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"));

Isso o leva de volta a:

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

Novamente, chamar um método em uma referência nula resulta em um NullPointerException , e você precisará verificar se a variável de referência é nula antes de usá-la.

StringUtils.compare()

A declaração desse método fica assim:

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

Este método compara duas strings lexicograficamente, como o método java.lang.String.compareTo() faz , retornando:

• 0 se str1 for igual a str2 (ou ambos forem nulos)
• O valor é menor que 0 se str1 for menor que str2
• Valor maior que 0 se str1 for maior que str2

A ordem lexicográfica é a ordem do dicionário. Vamos ver como podemos usar isso em nosso 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"));

Nós temos:

0
-1
1
32
0

Observação: um valor nulo é considerado menor que um valor não nulo . Dois valores nulos são considerados iguais.

Verificando se uma string contém outra substring

Para fazer isso, StringUtils possui 5 métodos:

• contém()
• contémIgnorarCase()
• contémAny()
• contémNenhum()
• contémSomente()

O método contains() retorna true ou false dependendo se a sequência de busca está contida em outra sequência ou não.

Se null for passado para tal método , ele retornará false . Se não nulo for passado , o método simplesmente chamará java.lang.String.indexOf(String str) no objeto passado.

Exemplos:

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"));

O método diferencia maiúsculas de minúsculas, então a última chamada também retornará false :

false
true
false
false

O método containsAny() retorna true se a string passada como o primeiro argumento contiver pelo menos uma das substrings passadas nos argumentos 2-N.

Exemplo:

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

Exibirá:

true

Este método também diferencia maiúsculas de minúsculas.

método contémNone()

Quando você precisa verificar se uma determinada string não contém nada da lista, você pode usar o método containsNone() . O primeiro parâmetro é uma string e os seguintes parâmetros são strings que não devem estar no coletor de destino.

Exemplo:

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

Saída do console:

false

Trabalhando com substrings

Trabalhar com substrings é semelhante a trabalhar com métodos da classe String :

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

Esses métodos retornam uma substring da string str . A string é dada por dois índices: start e end . E como sempre em Java, o último caractere do intervalo é end-1 . Qual é a vantagem desses métodos?

Se você passar null para tal método , ele simplesmente retornará null em vez de lançar uma exceção. Esses métodos oferecem suporte a valores de índice negativos. Nesse caso, a string é considerada um loop fechado. O último caractere é seguido pelo primeiro e assim por diante.

Vejamos como podemos utilizá-lo:

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

Executando o código acima nos dá:

ts j
ets java
null

StringUtils.split()

Um método que permite dividir uma string em substrings usando um caractere delimitador especial. Se houver um na string de destino, o método retornará uma matriz de substrings. Se não houver nenhum caractere, uma matriz vazia será retornada. Bem, se null for passado para o método , ele retornará null . Vamos dar uma olhada neste código e como o método funciona:

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.join()

O método join() permite concatenar um array de strings em uma única string. Ao mesmo tempo, um caractere separador especial pode ser passado para ele, que será adicionado entre substrings na string resultante. E se null for passado para o método , ele retornará null .

Este método é exatamente o oposto do método split() . Vejamos este exemplo simples:

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

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

Executando o código acima nos dá:

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

StringUtils.replace()

Procura uma string dentro de uma string, localiza-a se existir e substitui todas as suas ocorrências por uma nova string.

A declaração desse método fica assim:

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

Se a string de pesquisa não for encontrada no texto, nada acontecerá e o texto permanecerá o mesmo. Seguindo a mesma lógica, se o texto for null , esse método retorna null . Se você estiver procurando por uma string nula ou substituindo uma substring por null , o método retornará a string original.

Vamos tentar este método:

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

Resultado:

CodeGym is the cool

• Guia para a classe StringUtils do Apache Commons em Java
• Apache Commons Java StringUtils Guia de classe