Wie überprüfe ich, ob ein Java-String nicht nur aus Leerzeichen besteht?

Ich möchte mit Java überprüfen, ob Java String oder Zeichenarray nicht nur aus Leerzeichen besteht.

Dies ist eine sehr ähnliche Frage, außer dass es sich um Javascript handelt:
Wie kann ich überprüfen, ob die Zeichenfolge Zeichen und Leerzeichen enthält, nicht nur Leerzeichen?

BEARBEITEN : Ich habe das Bit über alphanumerische Zeichen entfernt, daher ist es sinnvoller.

Die kürzeste Lösung, die ich mir vorstellen kann:

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

Dies prüft nur auf (nicht) Leerzeichen. Wenn Sie nach bestimmten Zeichenklassen match()suchen möchten, müssen Sie den Mächtigen mit einem regulären Ausdruck verwenden, wie z.

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

... die nach mindestens einem (ASCII) alphanumerischen Zeichen sucht.

Ich würde die Apache Commons Lang-Bibliothek verwenden. Es hat eine Klasse namens StringUtils, die für alle Arten von String-Operationen nützlich ist. Um zu überprüfen, ob ein String nicht nur aus Leerzeichen besteht, können Sie Folgendes verwenden:

StringUtils.isBlank(<your string>)

Hier ist die Referenz: StringUtils.isBlank

Etwas kürzer als von Carl Smotricz erwähnt:

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

Wenn Sie Java 11 verwenden , ist die neue isBlankZeichenfolgenmethode hilfreich:

!s.isBlank();

Wenn Sie Java 8, 9 oder 10 verwenden , können Sie einen einfachen Stream erstellen, um zu überprüfen, ob eine Zeichenfolge nicht nur Leerzeichen ist:

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

Diese Lösungen erfordern nicht nur keine Bibliotheken von Drittanbietern wie Apache Commons Lang, sondern haben auch den Vorteil, dass sie Leerzeichen und nicht nur ' 'Leerzeichen verarbeiten können, wie dies trimin vielen anderen Antworten vorgeschlagen würde. In den Javadocs finden Sie eine vollständige Liste aller unterstützten Leerraumtypen. Beachten Sie, dass in beiden Fällen auch leere Zeichenfolgen abgedeckt sind.

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

Beachten Sie die Verwendung von Back-Slash Cap-S, was "Nicht-Leerzeichen" bedeutet.

Ich würde wetten, dass dies die einfachste (und vielleicht schnellste?) Lösung ist.

Diese Antwort konzentriert sich mehr auf die Nebenbemerkung " dh hat mindestens ein alphanumerisches Zeichen ". Außerdem fügt es der anderen (früheren) Lösung nicht zu viel hinzu, außer dass es Sie mit NPE nicht verletzt, falls der String es ist null.

Wir wollen, falsewenn (1) s ist nulloder (2) s leer ist oder (3) s nur Whitechars enthält.

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

Wenn Sie nur nach Leerzeichen suchen und sich nicht für Null interessieren, können Sie org.apache.commons.lang.StringUtils.isWhitespace (String str) verwenden.

StringUtils.isWhitespace(String str);

(Überprüft, ob der String nur Leerzeichen enthält.)

Wenn Sie auch nach null suchen möchten (einschließlich Leerzeichen), dann

StringUtils.isBlank(String str);

Mit Java-11 + können Sie mithilfe der String.isBlankAPI überprüfen, ob die angegebene Zeichenfolge nicht ausschließlich aus Leerzeichen besteht.

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

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

Der Javadoc für das gleiche ist:

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

Die Trimmmethode sollte für Sie gut funktionieren.

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

Gibt eine Kopie der Zeichenfolge zurück, wobei führende und nachfolgende Leerzeichen weggelassen werden. Wenn dieses String-Objekt eine leere Zeichenfolge darstellt oder das erste und das letzte Zeichen der Zeichenfolge, die durch dieses String-Objekt dargestellt werden, Codes haben, die größer als '\ u0020' (das Leerzeichen) sind, wird ein Verweis auf dieses String-Objekt zurückgegeben.

Wenn die Zeichenfolge kein Zeichen mit einem Code größer als '\ u0020' enthält, wird ein neues Zeichenfolgenobjekt erstellt und zurückgegeben, das eine leere Zeichenfolge darstellt.

Andernfalls sei k der Index des ersten Zeichens in der Zeichenfolge, dessen Code größer als '\ u0020' ist, und m der Index des letzten Zeichens in der Zeichenfolge, dessen Code größer als '\ u0020' ist. Es wird ein neues String-Objekt erstellt, das den Teilstring dieses Strings darstellt, der mit dem Zeichen am Index k beginnt und mit dem Zeichen am Index m endet, dh das Ergebnis dieser Zeichenfolge (k, m + 1).

Diese Methode kann verwendet werden, um Leerzeichen vom Anfang und Ende eines Strings abzuschneiden. Tatsächlich werden auch alle ASCII-Steuerzeichen abgeschnitten.

Rückgabe: Eine Kopie dieser Zeichenfolge mit entferntem und nachfolgendem Leerzeichen oder diese Zeichenfolge, wenn kein führender oder nachfolgender Leerraum vorhanden ist. Führender oder nachfolgender Leerraum.

Sie können zuschneiden und dann mit einer leeren Zeichenfolge vergleichen oder möglicherweise die Länge auf 0 überprüfen.

Alternative:

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

trim () und andere erwähnte reguläre Ausdrücke funktionieren nicht für alle Arten von Leerzeichen

dh: Unicode-Zeichen 'LINE SEPARATOR' http://www.fileformat.info/info/unicode/char/2028/index.htm

Die Java-Funktionen Character.isWhitespace () decken alle Situationen ab.

Aus diesem Grund sollte die bereits erwähnte Lösung StringUtils.isWhitespace (String) / oder StringUtils.isBlank (String) verwendet werden.

StringUtils.isEmptyOrWhitespaceOnly(<your string>)

wird prüfen: - ist es null - ist es nur Leerzeichen - ist es leere Zeichenfolge ""

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

Nur ein Leistungsvergleich unter openjdk 13, Windows 10. Für jeden dieser Texte:

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

führte einen der folgenden Tests durch:

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

jeweils 10.000.000 mal.

Die Ergebnisse:

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

Überraschenderweise ist das Trimmen + Leer am schnellsten. Auch wenn der zugeschnittene Text erstellt werden muss. Immer noch schneller als eine einfache for-Schleife, die nach einem einzigen Zeichen ohne Leerzeichen sucht ...

BEARBEITEN: Je länger der Text, desto mehr Zahlen unterscheiden sich. Das Trimmen von Langtext dauert länger als nur eine einfache Schleife. Die regulären Ausdrücke sind jedoch immer noch die langsamste Lösung.

Während ich persönlich würde lieber sein !str.isBlank(), als andere bereits vorgeschlagen (oder str -> !str.isBlank()als Prädikat), eine modernere und effizientere Version des str.trim()oben erwähnten Ansatzes wäre mit str.strip()- unter Berücksichtigung nulls als „Leerzeichen“:

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

Zum Beispiel als Prädikat zur Verwendung mit Streams, z. B. in einem Unit-Test:

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