Come posso verificare che una stringa Java non sia tutta bianca?

Voglio verificare che Java String o array di caratteri non sia costituito solo da spazi bianchi, utilizzando Java?

Questa è una domanda molto simile tranne che è Javascript:
Come posso verificare se la stringa contiene caratteri e spazi bianchi, non solo spazi bianchi?

EDIT : ho rimosso la parte relativa ai caratteri alfanumerici, quindi ha più senso.

La soluzione più breve che mi viene in mente:

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

Questo controlla solo lo spazio (non) bianco. Se vuoi controllare determinate classi di caratteri, devi usare il potente match()con una regexp come:

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

... che verifica almeno un carattere alfanumerico (ASCII).

Vorrei usare la libreria Apache Commons Lang. Ha una classe chiamata StringUtils che è utile per tutti i tipi di operazioni su String. Per verificare se una stringa non è tutti spazi bianchi, è possibile utilizzare quanto segue:

StringUtils.isBlank(<your string>)

Ecco il riferimento: StringUtils.isBlank

Leggermente più breve di quanto menzionato da 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 si utilizza Java 11 , il nuovo isBlankmetodo stringa sarà utile:

!s.isBlank();

Se si utilizza Java 8, 9 o 10 , è possibile creare un flusso semplice per verificare che una stringa non sia solo uno spazio bianco:

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

Oltre a non richiedere librerie di terze parti come Apache Commons Lang, queste soluzioni hanno il vantaggio di gestire qualsiasi carattere di spazio bianco e non solo ' 'spazi semplici come una trimsoluzione basata su base suggerita in molte altre risposte. È possibile fare riferimento a Javadocs per un elenco completo di tutti i tipi di spazi bianchi supportati. Si noti che anche le stringhe vuote sono coperte in entrambi i casi.

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

Nota l'uso di back-slash cap-S, che significa "carattere non bianco"

Scommetto che questa è la soluzione più semplice (e forse la più veloce?).

Questa risposta si concentra maggiormente sul sidenote " cioè ha almeno un carattere alfanumerico ". Oltre a ciò, non aggiunge troppo all'altra soluzione (precedente), tranne per il fatto che non ti fa del male con NPE nel caso in cui lo sia String null.

Vogliamo falsese (1) s è nullo (2) s è vuoto o (3) s contiene solo whitechars.

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

Se stai controllando solo gli spazi bianchi e non ti interessa nulla, puoi utilizzare org.apache.commons.lang.StringUtils.isWhitespace (String str),

StringUtils.isWhitespace(String str);

(Verifica se la stringa contiene solo spazi).

Se si desidera anche verificare la presenza di null (compresi gli spazi bianchi), allora

StringUtils.isBlank(String str);

Con Java-11 +, puoi utilizzare l' String.isBlankAPI per verificare se la stringa specificata non è tutta composta da spazi bianchi -

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

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

Il javadoc per lo stesso è:

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

Il metodo di taglio dovrebbe funzionare perfettamente per te.

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

Restituisce una copia della stringa, con spazi bianchi iniziali e finali omessi. Se questo oggetto String rappresenta una sequenza di caratteri vuota, oppure il primo e l'ultimo carattere della sequenza di caratteri rappresentato da questo oggetto String hanno entrambi codici maggiori di '\ u0020' (il carattere spazio), viene restituito un riferimento a questo oggetto String.

Altrimenti, se nella stringa non è presente alcun carattere con un codice maggiore di '\ u0020', viene creato e restituito un nuovo oggetto String che rappresenta una stringa vuota.

Altrimenti, sia k l'indice del primo carattere nella stringa il cui codice è maggiore di '\ u0020', e sia m l'indice dell'ultimo carattere nella stringa il cui codice è maggiore di '\ u0020'. Viene creato un nuovo oggetto String, che rappresenta la sottostringa di questa stringa che inizia con il carattere all'indice k e termina con il carattere all'indice m, ovvero il risultato di this.substring (k, m + 1).

Questo metodo può essere usato per tagliare gli spazi bianchi dall'inizio e dalla fine di una stringa; infatti, taglia anche tutti i caratteri di controllo ASCII.

Restituisce: una copia di questa stringa con spazio bianco iniziale e finale rimosso, oppure questa stringa se non ha spazio bianco iniziale o finale. Spazio bianco dominante o finale.

È possibile tagliare e quindi confrontare con una stringa vuota o eventualmente controllare la lunghezza per 0.

Alternativa:

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

trim () e altre espressioni regolari menzionate non funzionano per tutti i tipi di spazi bianchi

vale a dire: carattere Unicode 'LINE SEPARATOR' http://www.fileformat.info/info/unicode/char/2028/index.htm

Funzioni Java Character.isWhitespace () copre tutte le situazioni.

Ecco perché si dovrebbe usare la soluzione già menzionata StringUtils.isWhitespace (String) / o StringUtils.isBlank (String) .

StringUtils.isEmptyOrWhitespaceOnly(<your string>)

controllerà: - è nullo - è solo spazio - è stringa vuota ""

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

Solo un confronto delle prestazioni su openjdk 13, Windows 10. Per ciascuno di questi testi:

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

eseguito uno dei seguenti test:

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

ogni 10.000.000 di volte.

I risultati:

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

Abbastanza sorprendentemente il trim + vuoto è il più veloce. Anche se deve costruire il testo ritagliato. Ancora più veloce del semplice for-loop in cerca di un singolo personaggio non bianco ...

EDIT: il testo più lungo, più numeri differiscono. Il taglio del testo lungo richiede più tempo rispetto al semplice ciclo. Tuttavia, i regex sono ancora la soluzione più lenta.

Mentre personalmente preferirei !str.isBlank(), come altri già suggerito (o str -> !str.isBlank()come Predicato), userei una versione più moderna ed efficiente str.trim()dell'approccio sopra menzionato, str.strip()considerando i null come "spazi bianchi":

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

Ad esempio come Predicato, per l'uso con flussi, ad esempio in un test unitario:

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