Como verifico se uma String Java não é todos os espaços em branco?

Quero verificar se o Java String ou o array de caracteres não é composto apenas de espaços em branco, usando Java?

Esta é uma pergunta muito semelhante, exceto que é Javascript:
Como posso verificar se a string contém caracteres e espaços em branco, não apenas espaços em branco?

Edição : Eu removi o bit sobre caracteres alfanuméricos, por isso faz mais sentido.

Solução mais curta que consigo pensar:

if (string.trim().length() > 0) ...

Isso verifica apenas espaço em branco (não). Se você quiser verificar classes de caracteres específicas, precisará usar o poderoso match()com uma expressão regular como:

if (string.matches(".*\\w.*")) ...

... que verifica pelo menos um caractere alfanumérico (ASCII).

Eu usaria a biblioteca Apache Commons Lang. Possui uma classe chamada StringUtils, útil para todos os tipos de operações de String. Para verificar se uma String não é todos os espaços em branco, você pode usar o seguinte:

StringUtils.isBlank(<your string>)

Aqui está a referência: StringUtils.isBlank

Um pouco mais curto do que o mencionado por Carl Smotricz:

!string.trim().isEmpty();

StringUtils.isBlank(CharSequence)

https://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/StringUtils.html#isBlank-java.lang.CharSequence-

Se você estiver usando o Java 11 , o novo isBlankmétodo de cadeia será útil:

!s.isBlank();

Se você estiver usando Java 8, 9 ou 10 , poderá criar um fluxo simples para verificar se uma sequência não é apenas espaço em branco:

!s.chars().allMatch(Character::isWhitespace));

Além de não exigir bibliotecas de terceiros, como o Apache Commons Lang, essas soluções têm a vantagem de manipular qualquer caractere de espaço em branco, e não apenas ' 'espaços simples , como trimsugeriria uma solução baseada em muitas outras respostas. Você pode consultar os Javadocs para obter uma lista exaustiva de todos os tipos de espaços em branco suportados. Observe que cadeias vazias também são abordadas nos dois casos.

if(target.matches("\\S")) 
    // then string contains at least one non-whitespace character

Observe o uso da barra invertida cap-S, que significa "caractere sem espaço em branco"

Aposto que essa é a solução mais simples (e talvez a mais rápida?).

Esta resposta se concentra mais na nota lateral ", ou seja, possui pelo menos um caractere alfanumérico ". Além disso, ele não adiciona muito à outra solução (anterior), exceto que não o prejudica com o NPE, caso a String seja null.

Queremos falseque (1) s seja nullou (2) s esteja vazio ou (3) s contenha apenas whitechars.

public static boolean containsNonWhitespaceChar(String s) {
  return !((s == null) || "".equals(s.trim()));
}

Se você estiver verificando apenas o espaço em branco e não se importar com nulo, poderá usar org.apache.commons.lang.StringUtils.isWhitespace (String str),

StringUtils.isWhitespace(String str);

(Verifica se a String contém apenas espaço em branco.)

Se você também deseja procurar nulo (incluindo espaço em branco),

StringUtils.isBlank(String str);

Com o Java-11 +, você pode usar a String.isBlankAPI para verificar se a sequência especificada não é toda composta de espaço em branco -

String str1 = "    ";
System.out.println(str1.isBlank()); // made up of all whitespaces, prints true

String str2 = "    a";
System.out.println(str2.isBlank()); // prints false

O javadoc para o mesmo é:

/**
 * Returns {@code true} if the string is empty or contains only
 * {@link Character#isWhitespace(int) white space} codepoints,
 * otherwise {@code false}.
 *
 * @return {@code true} if the string is empty or contains only
 *         {@link Character#isWhitespace(int) white space} codepoints,
 *         otherwise {@code false}
 *
 * @since 11
 */
public boolean isBlank()

O método de corte deve funcionar muito bem para você.

http://download.oracle.com/docs/cd/E17476_01/javase/1.4.2/docs/api/java/lang/String.html#trim ()

Retorna uma cópia da string, com espaços em branco à esquerda e à direita omitidos. Se esse objeto String representar uma sequência de caracteres vazia, ou o primeiro e o último caracteres da sequência de caracteres representados por esse objeto String tiverem códigos maiores que '\ u0020' (o caractere de espaço), será retornada uma referência a esse objeto String.

Caso contrário, se não houver um caractere com um código maior que '\ u0020' na string, um novo objeto String representando uma string vazia será criado e retornado.

Caso contrário, seja k o índice do primeiro caractere na string cujo código é maior que '\ u0020' e m seja o índice do último caractere na string cujo código seja maior que '\ u0020'. Um novo objeto String é criado, representando a substring dessa string que começa com o caractere no índice k e termina com o caractere no índice m - ou seja, o resultado desse subconjunto (k, m + 1).

Este método pode ser usado para aparar espaços em branco desde o início e o final de uma string; de fato, também apara todos os caracteres de controle ASCII.

Retorna: Uma cópia dessa sequência com o espaço em branco à esquerda e à direita removido ou essa sequência se não tiver espaço em branco à esquerda ou à direita. Espaço em branco à esquerda ou à direita.

Você pode aparar e comparar com uma sequência vazia ou possivelmente verificar o comprimento como 0.

Alternativo:

boolean isWhiteSpaces( String s ) {
    return s != null && s.matches("\\s+");
 }

trim () e outras expressões regulares mencionadas não funcionam para todos os tipos de espaços em branco

ou seja: Caractere Unicode 'LINE SEPARATOR' http://www.fileformat.info/info/unicode/char/2028/index.htm

Funções Java Character.isWhitespace () abrange todas as situações.

É por isso que a solução mencionada StringUtils.isWhitespace (String) / ou StringUtils.isBlank (String) deve ser usada.

StringUtils.isEmptyOrWhitespaceOnly(<your string>)

irá verificar: - é nulo - é apenas espaço - é string vazia ""

https://www.programcreek.com/java-api-examples/?class=com.mysql.jdbc.StringUtils&method=isEmptyOrWhitespaceOnly

Apenas uma comparação de desempenho no openjdk 13, Windows 10. Para cada um desses textos:

"abcd"
"    "
" \r\n\t"
" ab "
" \n\n\r\t   \n\r\t\t\t   \r\n\r\n\r\t \t\t\t\r\n\n"
"lorem ipsum dolor sit amet  consectetur adipisici elit"
"1234657891234567891324569871234567891326987132654798"

executou um dos seguintes testes:

// trim + empty
input.trim().isEmpty()

// simple match
input.matches("\\S")

// match with precompiled pattern
final Pattern PATTERN = Pattern.compile("\\S");
PATTERN.matcher(input).matches()

// java 11's isBlank
input.isBlank()

cada 10.000.000 vezes.

Os resultados:

METHOD    min   max   note
trim:      18   313   much slower if text not trimmed
match:   1799  2010   
pattern:  571   662   
isBlank:   60   338   faster the earlier hits the first non-whitespace character

Surpreendentemente, o trim + empty é o mais rápido. Mesmo que seja necessário construir o texto aparado. Ainda mais rápido que o loop for simples, procurando por um único caractere sem espaço em branco ...

EDIT: Quanto maior o texto, mais números diferem. O corte de texto longo leva mais tempo do que apenas um loop simples. No entanto, os regexs ainda são a solução mais lenta.

Enquanto pessoalmente eu preferiria !str.isBlank(), como outros já sugeriram (ou str -> !str.isBlank()como predicado), uma versão mais moderna e eficiente da str.trim()abordagem mencionada acima, estaria usando str.strip()- considerando nulos como "espaço em branco":

if (str != null && str.strip().length() > 0) {...}

Por exemplo, como Predicado, para uso com fluxos, por exemplo, em um teste de unidade:

@Test
public void anyNonEmptyStrippedTest() {
    String[] strings = null;
    Predicate<String> isNonEmptyStripped = str -> str != null && str.strip().length() > 0;
    assertTrue(Optional.ofNullable(strings).map(arr -> Stream.of(arr).noneMatch(isNonEmptyStripped)).orElse(true));
    strings = new String[] { null, "", " ", "\\n", "\\t", "\\r" };
    assertTrue(Optional.ofNullable(strings).map(arr -> Stream.of(arr).anyMatch(isNonEmptyStripped)).orElse(true));
    strings = new String[] { null, "", " ", "\\n", "\\t", "\\r", "test" };
}