¿Cómo verifico que una cadena de Java no son todos espacios en blanco?

¿Quiero comprobar que Java String o la matriz de caracteres no se compone solo de espacios en blanco, usando Java?

Esta es una pregunta muy similar, excepto que es Javascript:
¿Cómo puedo verificar si la cadena contiene caracteres y espacios en blanco, no solo espacios en blanco?

EDITAR : eliminé un poco sobre los caracteres alfanuméricos, por lo que tiene más sentido.

La solución más corta que se me ocurre:

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

Esto solo comprueba el espacio en blanco (no). Si desea verificar determinadas clases de caracteres, debe usar el poderoso match()con una expresión regular como:

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

... que comprueba al menos un carácter alfanumérico (ASCII).

Usaría la biblioteca Lang de Apache Commons. Tiene una clase llamada StringUtils que es útil para todo tipo de operaciones de String. Para verificar si una cadena no es todos espacios en blanco, puede usar lo siguiente:

StringUtils.isBlank(<your string>)

Aquí está la referencia: StringUtils.isBlank

Ligeramente más corto que lo 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-

Si está utilizando Java 11 , el nuevo isBlankmétodo de cadena será útil:

!s.isBlank();

Si está utilizando Java 8, 9 o 10 , puede crear una secuencia simple para verificar que una cadena no sea solo un espacio en blanco:

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

Además de no requerir bibliotecas de terceros, como Apache Commons Lang, estas soluciones tienen la ventaja de manejar cualquier carácter de espacio en blanco, y no solo ' 'espacios simples , como lo haría una trimsolución basada en lo sugerido en muchas otras respuestas. Puede consultar los Javadocs para obtener una lista exhaustiva de todos los tipos de espacios en blanco admitidos. Tenga en cuenta que las cadenas vacías también están cubiertas en ambos casos.

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

Tenga en cuenta el uso de la barra diagonal inversa cap-S, que significa "char no espacio en blanco"

Apuesto a que esta es la solución más simple (¿y quizás la más rápida?).

Esta respuesta se centra más en la nota al margen " es decir, tiene al menos un carácter alfanumérico ". Además de eso, no agrega demasiado a la otra solución (anterior), excepto que no te hace daño con NPE en caso de que la cadena sea null.

Queremos falsesi (1) s está nullo (2) s está vacío o (3) s solo contiene caracteres en blanco.

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

Si solo está buscando espacios en blanco y no le importa nulo, puede usar org.apache.commons.lang.StringUtils.isWhitespace (String str),

StringUtils.isWhitespace(String str);

(Comprueba si la cadena contiene solo espacios en blanco).

Si también desea verificar nulo (incluido el espacio en blanco), entonces

StringUtils.isBlank(String str);

Con Java-11 +, puede hacer uso de la String.isBlankAPI para verificar si la cadena dada no está compuesta de espacios en blanco:

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

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

El javadoc para lo mismo es:

/**
 * 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()

El método de recorte debería funcionar muy bien para usted.

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

Devuelve una copia de la cadena, con espacios en blanco iniciales y finales omitidos. Si este objeto String representa una secuencia de caracteres vacía, o los primeros y últimos caracteres de la secuencia de caracteres representados por este objeto String tienen códigos mayores que '\ u0020' (el carácter de espacio), se devuelve una referencia a este objeto String.

De lo contrario, si no hay ningún carácter con un código mayor que '\ u0020' en la cadena, se crea y devuelve un nuevo objeto de cadena que representa una cadena vacía.

De lo contrario, sea k el índice del primer carácter de la cadena cuyo código sea mayor que '\ u0020', y sea m el índice del último carácter de la cadena cuyo código sea mayor que '\ u0020'. Se crea un nuevo objeto String, que representa la subcadena de esta cadena que comienza con el carácter en el índice k y termina con el carácter en el índice m, es decir, el resultado de this.substring (k, m + 1).

Este método puede usarse para recortar espacios en blanco desde el principio y el final de una cadena; de hecho, también recorta todos los caracteres de control ASCII.

Devuelve: Una copia de esta cadena con el espacio en blanco inicial y final eliminado, o esta cadena si no tiene espacio en blanco inicial o final. Espacio en blanco inicial o final.

Puede recortar y luego comparar con una cadena vacía o posiblemente verificar la longitud para 0.

Alternativa:

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

trim () y otras expresiones regulares mencionadas no funcionan para todos los tipos de espacios en blanco

es decir: Carácter Unicode 'SEPARADOR DE LÍNEA' http://www.fileformat.info/info/unicode/char/2028/index.htm

Funciones de Java Character.isWhitespace () cubre todas las situaciones.

Es por eso que ya se debe usar la solución StringUtils.isWhitespace (String) / o StringUtils.isBlank (String) .

StringUtils.isEmptyOrWhitespaceOnly(<your string>)

comprobará: - es nulo - es solo espacio - es una cadena vacía ""

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

Solo una comparación de rendimiento en openjdk 13, Windows 10. Para cada uno de estos 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"

ejecutó una de las siguientes pruebas:

// 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 veces.

Los 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

Sorprendentemente, el trim + empty es el más rápido. Incluso si necesita construir el texto recortado. Aún más rápido que el simple bucle for buscando un solo carácter sin espacios en blanco ...

EDITAR: cuanto más largo sea el texto, más números difieren. Recortar texto largo lleva más tiempo que un simple bucle. Sin embargo, las expresiones regulares siguen siendo la solución más lenta.

Si bien personalmente preferiría !str.isBlank(), como otros ya sugirieron (o str -> !str.isBlank()como un predicado) str.trim(), se usaría una versión más moderna y eficiente del enfoque mencionado anteriormente, str.strip()considerando los nulos como "espacios en blanco":

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

Por ejemplo, como Predicate, para usar con flujos, por ejemplo, en una prueba unitaria:

@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" };
}