Làm thế nào tôi có thể kiểm tra xem một chuỗi không rỗng và không trống?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}

Thế còn isEmpty () ?

if(str != null && !str.isEmpty())

Hãy chắc chắn sử dụng các phần &&theo thứ tự này, vì java sẽ không tiến hành đánh giá phần thứ hai nếu phần thứ nhất &&không thành công, do đó đảm bảo bạn sẽ không nhận được ngoại lệ con trỏ null từ str.isEmpty()nếu strlà null.

Coi chừng, nó chỉ khả dụng kể từ Java SE 1.6. Bạn phải kiểm tra str.length() == 0các phiên bản trước.

Để bỏ qua khoảng trắng là tốt:

if(str != null && !str.trim().isEmpty())

(vì Java 11 str.trim().isEmpty()có thể được giảm xuống str.isBlank()cũng sẽ kiểm tra các khoảng trắng Unicode khác)

Được bọc trong một chức năng tiện dụng:

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

Trở thành:

if( !empty( str ) )

Sử dụng org.apache.commons.lang.StringUtils

Tôi thích sử dụng Apache commons-lang cho các loại điều này và đặc biệt là lớp tiện ích StringUtils :

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
} 

Chỉ cần thêm Android vào đây:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}

Để thêm vào @BJorn và @SeanPatrickFloyd Cách Guava để làm điều này là:

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

Đôi khi Commons Lang dễ đọc hơn nhưng tôi đã dần dần tin tưởng nhiều hơn vào Guava cộng với đôi khi Commons Lang khó hiểu khi nói đến isBlank() (như trong khoảng trắng hay không).

Phiên bản Commons Lang của Guava isBlanksẽ là:

Strings.nullToEmpty(str).trim().isEmpty()

Tôi sẽ nói mã không cho phép ""(trống) VÀ null đáng ngờ và có khả năng có lỗi ở chỗ nó có thể không xử lý tất cả các trường hợp không cho phép nullcó ý nghĩa (mặc dù đối với SQL tôi có thể hiểu vì SQL / HQL là lạ '').

str != null && str.length() != 0

cách khác

str != null && !str.equals("")

hoặc là

str != null && !"".equals(str)

Lưu ý: Kiểm tra thứ hai (thay thế thứ nhất và thứ hai) giả sử str không phải là null. Chỉ ổn vì kiểm tra đầu tiên đang thực hiện điều đó (và Java không thực hiện kiểm tra thứ hai nếu kiểm tra đầu tiên là sai)!

QUAN TRỌNG: KHÔNG sử dụng == để bình đẳng chuỗi. == kiểm tra con trỏ bằng nhau, không phải giá trị. Hai chuỗi có thể ở các địa chỉ bộ nhớ khác nhau (hai trường hợp) nhưng có cùng giá trị!

Hầu như mọi thư viện tôi biết đều định nghĩa một lớp tiện ích được gọi là StringUtils, StringUtilhoặcStringHelper , chúng thường bao gồm phương thức bạn đang tìm kiếm.

Sở thích cá nhân của tôi là Apache Commons / Lang , trong lớp StringUtils , bạn có cả hai

(Đầu tiên kiểm tra xem một chuỗi là null hay rỗng, thứ hai kiểm tra xem nó là null, chỉ trống hay khoảng trắng)

Có các lớp tiện ích tương tự trong Spring, Wicket và rất nhiều lib khác. Nếu bạn không sử dụng các thư viện bên ngoài, bạn có thể muốn giới thiệu một lớp StringUtils trong dự án của riêng bạn.

Cập nhật: đã nhiều năm trôi qua và ngày nay tôi khuyên bạn nên sử dụng phương pháp của GuavaStrings.isNullOrEmpty(string) .

Điều này làm việc cho tôi:

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

Trả về true nếu chuỗi đã cho là null hoặc là chuỗi rỗng.

Xem xét bình thường hóa các tham chiếu chuỗi của bạn với nullToEmpty. Nếu bạn làm như vậy, bạn có thể sử dụng String.isEmpty () thay vì phương thức này và bạn sẽ không cần các hình thức phương thức đặc biệt an toàn null như String.toUpperCase. Hoặc, nếu bạn muốn bình thường hóa "theo hướng khác", chuyển đổi các chuỗi rỗng thành null, bạn có thể sử dụng blankToNull.

Làm thế nào về:

if(str!= null && str.length() != 0 )

Sử dụng phương thức isNotBlank của Apache StringUtils như

StringUtils.isNotBlank(str)

Nó sẽ trả về true chỉ khi str không null và không rỗng.

Bạn nên sử dụng org.apache.commons.lang3.StringUtils.isNotBlank()hoặc org.apache.commons.lang3.StringUtils.isNotEmpty. Quyết định giữa hai điều này dựa trên những gì bạn thực sự muốn kiểm tra.

Các isNotBlank () kiểm tra rằng các tham số đầu vào là:

• có giá trị,
• không phải chuỗi rỗng ("")
• không phải là một chuỗi các ký tự khoảng trắng ("")

Các isNotEmpty () kiểm tra duy nhất mà các tham số đầu vào là

• có giá trị
• không phải chuỗi rỗng ("")

Trả về đúng hay sai dựa trên đầu vào

Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);

Nếu bạn không muốn bao gồm toàn bộ thư viện; chỉ cần bao gồm mã bạn muốn từ nó. Bạn sẽ phải tự duy trì nó; nhưng đó là một chức năng khá thẳng về phía trước. Ở đây nó được sao chép từ commons.apache.org

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}

Đó là một chút quá muộn, nhưng đây là một phong cách chức năng kiểm tra:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });

Có một phương pháp mới trong java-11: String#isBlank

Trả về true nếu chuỗi rỗng hoặc chỉ chứa các điểm mã khoảng trắng, nếu không thì sai.

jshell> "".isBlank()
$7 ==> true

jshell> " ".isBlank()
$8 ==> true

jshell> " ! ".isBlank()
$9 ==> false

Điều này có thể được kết hợp với Optionalđể kiểm tra xem chuỗi là null hay rỗng

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

Chuỗi # isBlank

kiểm tra bằng với một chuỗi rỗng và null trong cùng một điều kiện:

if(!"".equals(str) && str != null) {
    // do stuff.
}

Không ném NullPointerExceptionnếu str là null, vì Object.equals()trả về false nếu arg là null.

các cấu trúc khác str.equals("")sẽ ném kinh hoàng NullPointerException. Một số người có thể coi hình thức xấu khi sử dụng một chuỗi ký tự như là đối tượng khi equals()được gọi nhưng nó thực hiện công việc.

Đồng thời kiểm tra câu trả lời này: https://stackoverflow.com/a/531825/1532705

Giải pháp đơn giản:

private boolean stringNotEmptyOrNull(String st) {
    return st != null && !st.isEmpty();
}

Như seanizer đã nói ở trên, Apache StringUtils rất tuyệt vời cho việc này, nếu bạn muốn bao gồm ổi, bạn nên làm như sau;

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

Tôi cũng có thể khuyên bạn nên tham khảo các cột trong kết quả của bạn được đặt theo tên thay vì theo chỉ mục, điều này sẽ giúp mã của bạn dễ bảo trì hơn nhiều.

Tôi đã thực hiện chức năng tiện ích của riêng mình để kiểm tra một số chuỗi cùng một lúc, thay vì có một câu lệnh if đầy đủ if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Đây là chức năng:

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

vì vậy tôi chỉ có thể viết:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

Trong trường hợp bạn đang sử dụng Java 8 và muốn có một cách tiếp cận Lập trình hàm nhiều hơn, bạn có thể định nghĩa một Functionquản lý điều khiển và sau đó bạn có thể sử dụng lại nó và apply()bất cứ khi nào cần thiết.

Đến với thực hành, bạn có thể định nghĩa Functionnhư

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

Sau đó, bạn có thể sử dụng nó bằng cách gọi apply()phương thức là:

String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

Nếu bạn thích, bạn có thể xác định một Functionkiểm tra nếu Stringtrống và sau đó phủ nhận nó với !.

Trong trường hợp này, Functionsẽ trông như:

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

Sau đó, bạn có thể sử dụng nó bằng cách gọi apply()phương thức là:

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true

Với Java 8 Tùy chọn, bạn có thể làm:

public Boolean isStringCorrect(String str) {
    return Optional.ofNullable(str)
            .map(String::trim)
            .map(string -> !str.isEmpty())
            .orElse(false);
}

Trong biểu thức này, bạn cũng sẽ xử lý Strings bao gồm các khoảng trắng.

Bạn có thể sử dụng StringUtils.isEmpty (), nó sẽ cho kết quả đúng nếu chuỗi là null hoặc rỗng.

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

sẽ cho kết quả

str1 là null hoặc rỗng

str2 là null hoặc rỗng

Tôi sẽ tư vấn cho Guava hoặc Apache Commons theo nhu cầu thực tế của bạn. Kiểm tra các hành vi khác nhau trong mã ví dụ của tôi:

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

Kết quả:
Apache:
a trống
b là trống
c trống
Google:
b là NullOrEmpty
c là NullOrEmpty

Nếu bạn đang sử dụng Spring Boot thì mã bên dưới sẽ thực hiện Công việc

StringUtils.hasLength(str)

Để hoàn thiện: Nếu bạn đã sử dụng khung công tác Spring , StringUtils cung cấp phương thức

org.springframework.util.StringUtils.hasLength(String str)

Trả về: true nếu Chuỗi không rỗng và có độ dài

cũng như phương pháp

org.springframework.util.StringUtils.hasText(String str)

Trả về: true nếu Chuỗi không rỗng, độ dài của nó lớn hơn 0 và nó không chỉ chứa khoảng trắng

Đơn giản, để bỏ qua khoảng trắng là tốt:

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}

Nếu bạn sử dụng Spring framework thì bạn có thể sử dụng phương thức:

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

Phương thức này chấp nhận bất kỳ Đối tượng nào làm đối số, so sánh nó với null và Chuỗi rỗng. Kết quả là, phương thức này sẽ không bao giờ trả về true cho một đối tượng không phải chuỗi không null.

Cách tốt hơn để xử lý null trong chuỗi là,

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

Nói ngắn gọn,

str.length()>0 && !str.equalsIgnoreCase("null")

Để kiểm tra xem tất cả các thuộc tính chuỗi trong một đối tượng có trống không (Thay vì sử dụng! = Null trên tất cả các tên trường theo cách tiếp cận api phản chiếu java

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

Phương thức này sẽ trả về true nếu tất cả các giá trị trường Chuỗi đều trống, Nó sẽ trả về false nếu có bất kỳ một giá trị nào trong các thuộc tính Chuỗi

Tôi đã gặp một tình huống trong đó tôi phải kiểm tra xem "null" (dưới dạng chuỗi) phải được coi là trống. Ngoài ra khoảng trắng và một null thực tế phải trả về true. Cuối cùng tôi đã giải quyết được chức năng sau ...

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}

Trong trường hợp bạn cần xác thực các tham số phương thức của mình, bạn có thể sử dụng theo phương pháp đơn giản

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

Thí dụ:

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}