Làm thế nào để kiểm tra xem chuỗi của tôi có bằng null không?

Tôi muốn thực hiện một số hành động CHỈ NẾU chuỗi của tôi có một giá trị có ý nghĩa. Vì vậy, tôi đã thử điều này.

if (!myString.equals("")) {
doSomething
}

và điều này

if (!myString.equals(null)) {
doSomething
}

và điều này

if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}

và điều này

if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}

và điều này

if ( myString.length()>0) {
doSomething
}

Và trong tất cả các trường hợp, chương trình của tôi doSomethingbất chấp thực tế là chuỗi của tôi là EMPTY. Nó bằng null. Vì vậy, điều gì là sai với điều đó?

THÊM:

Tôi tìm thấy lý do của vấn đề. Biến được khai báo là một chuỗi và do đó, nullđược gán cho biến này đã được chuyển thành "null"! Vì vậy, if (!myString.equals("null"))làm việc.

if (myString != null && !myString.isEmpty()) {
  // doSomething
}

Khi nhận xét thêm, bạn nên biết về điều khoản này trong equalshợp đồng:

Từ Object.equals(Object):

Đối với bất kỳ giá trị tham chiếu không null x, x.equals(null)nên return false.

Cách để so sánh nulllà sử dụng x == nullvà x != null.

Hơn nữa, x.fieldvà x.method()ném NullPointerExceptionnếu x == null.

Nếu myStringlà null, sau đó gọi myString.equals(null)hoặc myString.equals("")sẽ thất bại với a NullPointerException. Bạn không thể gọi bất kỳ phương thức cá thể nào trên một biến null.

Kiểm tra null đầu tiên như thế này:

if (myString != null && !myString.equals("")) {
    //do something
}

Điều này sử dụng đánh giá ngắn mạch để không thử .equalsnếu myStringkhông kiểm tra null.

Apache commons StringUtils.isNotEmptylà cách tốt nhất để đi.

Nếu myString trên thực tế là null, thì mọi cuộc gọi đến tham chiếu sẽ không thành công với Ngoại lệ con trỏ Null (NPE). Vì java 6, hãy sử dụng #isEmpty thay vì kiểm tra độ dài (trong mọi trường hợp KHÔNG BAO GIỜ tạo Chuỗi trống mới bằng kiểm tra).

if (myString != null &&  !myString.isEmpty()){
    doSomething();
}

Ngẫu nhiên nếu so sánh với chuỗi ký tự như bạn làm, sẽ đảo ngược câu lệnh để không phải kiểm tra null, nghĩa là,

if ("some string to check".equals(myString)){
  doSomething();
} 

thay vì :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}

ĐANG LÀM VIỆC !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}

Bạn cần kiểm tra xem myStringđối tượng là null:

if (myString != null) {
    doSomething
}

Nếu chuỗi của bạn là null, các cuộc gọi như thế này sẽ ném NullReferenceException:

myString.equals (null)

Nhưng dù sao, tôi nghĩ một phương pháp như thế này là những gì bạn muốn:

public static class StringUtils
{
    public static bool isNullOrEmpty(String myString)
    {
         return myString == null || "".equals(myString);
    }
}

Sau đó, trong mã của bạn, bạn có thể làm những việc như thế này:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}

Tôi sẽ khuyến khích sử dụng một tiện ích hiện có hoặc tạo phương thức của riêng bạn:

public static boolean isEmpty(String string) {
    return string == null || string.length() == 0;
}

Sau đó, chỉ sử dụng nó khi bạn cần nó:

if (! StringUtils.isEmpty(string)) {
  // do something
}

Như đã nói ở trên, | | và && toán tử ngắn mạch. Điều đó có nghĩa là ngay khi họ có thể xác định giá trị của họ, họ dừng lại. Vì vậy, nếu (chuỗi == null) là đúng, phần độ dài không cần phải được ước tính, vì biểu thức sẽ luôn luôn đúng. Tương tự như vậy với &&, trong đó nếu phía bên trái là sai, biểu thức luôn luôn sai và không cần phải đánh giá thêm.

Là một lưu ý bổ sung, sử dụng độ dài thường là một ý tưởng tốt hơn so với sử dụng .equals. Hiệu suất tốt hơn một chút (không nhiều) và không yêu cầu tạo đối tượng (mặc dù hầu hết các trình biên dịch có thể tối ưu hóa điều này).

Thử,

myString!=null && myString.length()>0

 if (myString != null && myString.length() > 0) {

        // your magic here

 }

Ngẫu nhiên, nếu bạn đang thực hiện nhiều thao tác chuỗi, có một lớp Spring tuyệt vời với tất cả các loại phương thức hữu ích:

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html

Mỗi lần tôi phải xử lý chuỗi (hầu như mọi lúc) tôi đều dừng lại và tự hỏi cách nào thực sự là cách nhanh nhất để kiểm tra chuỗi trống. Tất nhiên, kiểm tra chuỗi. Độ dài == 0 phải là nhanh nhất vì Độ dài là một thuộc tính và không nên có bất kỳ xử lý nào ngoài việc truy xuất giá trị của thuộc tính. Nhưng sau đó tôi tự hỏi, tại sao lại có String.Empty? Tôi nên tự kiểm tra String.Empty nhanh hơn chiều dài, tôi tự nhủ. Vâng, tôi đã quyết định thử nghiệm nó. Tôi đã mã hóa một ứng dụng Windows Console nhỏ cho tôi biết phải mất bao lâu để thực hiện một kiểm tra nhất định cho 10 triệu lần sửa chữa. Tôi đã kiểm tra 3 chuỗi khác nhau: chuỗi NULL, chuỗi rỗng và chuỗi "". Tôi đã sử dụng 5 phương thức khác nhau: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == null | | str == "", str == null | | str.

String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds

str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds

str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds

str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds

str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds

Theo các kết quả này, trung bình kiểm tra str == nulllà nhanh nhất, nhưng có thể không phải lúc nào cũng mang lại những gì chúng ta đang tìm kiếm. if str = String.Emptyhoặc str = "", nó dẫn đến sai. Sau đó, bạn có 2 được gắn ở vị trí thứ hai: String.IsNullOrEmpty()và str == null || str.length == 0. Vì String.IsNullOrEmpty()trông đẹp hơn và dễ viết hơn (và nhanh hơn) nên tôi khuyên bạn nên sử dụng nó hơn các giải pháp khác.

Tôi sẽ làm một cái gì đó như thế này:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");

• Kiểm tra null kiểm tra xem myString có chứa phiên bản String hay không.
• length () trả về độ dài và tương đương với bằng ("").
• Kiểm tra xem myString có null trước không sẽ tránh được NullPulumException.

Tôi đã sử dụng StringUtil.isBlank(string)

Nó kiểm tra nếu một chuỗi trống: null, emtpy hoặc chỉ khoảng trắng.

Vì vậy, cái này là tốt nhất cho đến nay

Đây là phương pháp gốc từ các tài liệu

/**
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
    * @param string string to test
    * @return if string is blank
    */
    public static boolean isBlank(String string) {
        if (string == null || string.length() == 0)
            return true;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!StringUtil.isWhitespace(string.codePointAt(i)))
                return false;
        }
        return true;
    } 

Điều này sẽ làm việc:

if (myString != null && !myString.equals(""))
    doSomething
}

Nếu không, thì myString có thể có một giá trị mà bạn không mong đợi. Hãy thử in nó ra như thế này:

System.out.println("+" + myString + "+");

Sử dụng các ký hiệu '+' để bao quanh chuỗi sẽ hiển thị cho bạn nếu có thêm khoảng trắng trong đó mà bạn không hạch toán.

if(str.isEmpty() || str==null){ do whatever you want }

Được rồi, đây là cách các kiểu dữ liệu hoạt động trong Java. (Bạn phải xin lỗi tiếng Anh của tôi, tôi đang thử. Không sử dụng đúng vocab. Bạn phải phân biệt giữa hai trong số chúng. Các kiểu dữ liệu cơ sở và kiểu dữ liệu thông thường. Kiểu dữ liệu cơ bản tạo nên mọi thứ tồn tại. Ví dụ: là tất cả các số, char, boolean, v.v ... Các kiểu dữ liệu thông thường hoặc kiểu dữ liệu phức tạp là tất cả mọi thứ khác. Chuỗi là một mảng các ký tự, do đó là một kiểu dữ liệu phức tạp.

Mỗi biến mà bạn tạo thực sự là một con trỏ trên giá trị trong bộ nhớ của bạn. Ví dụ:

String s = new String("This is just a test");

biến "s" KHÔNG chứa Chuỗi. Nó là một con trỏ. Con trỏ này trỏ vào biến trong bộ nhớ của bạn. Khi bạn gọi System.out.println(anyObject), toString()phương thức của đối tượng đó được gọi. Nếu nó không ghi đè toStringtừ Object, nó sẽ in con trỏ. Ví dụ:

public class Foo{
    public static void main(String[] args) {
        Foo f = new Foo();
        System.out.println(f);
    }
}

>>>>
>>>>
>>>>Foo@330bedb4

Tất cả mọi thứ đằng sau "@" là con trỏ. Điều này chỉ hoạt động cho các loại dữ liệu phức tạp. Các kiểu dữ liệu nguyên thủy được lưu TRỰC TIẾP trong con trỏ của chúng. Vì vậy, thực sự không có con trỏ và các giá trị được lưu trữ trực tiếp.

Ví dụ:

int i = 123;

tôi KHÔNG lưu trữ một con trỏ trong trường hợp này. tôi sẽ lưu trữ giá trị số nguyên 123 (tính bằng byte ofc).

Được rồi vì vậy hãy trở lại với == nhà điều hành. Nó luôn so sánh con trỏ và không phải nội dung được lưu ở vị trí của con trỏ trong bộ nhớ.

Thí dụ:

String s1 = new String("Hallo");
String s2 = new String("Hallo");

System.out.println(s1 == s2);

>>>>> false

Cả hai Chuỗi này có một con trỏ khác nhau. String.equals (Chuỗi khác) tuy nhiên so sánh nội dung. Bạn có thể so sánh các kiểu dữ liệu nguyên thủy với toán tử '==' vì con trỏ của hai đối tượng khác nhau có cùng nội dung là bằng nhau.

Null có nghĩa là con trỏ trống rỗng. Một kiểu dữ liệu nguyên thủy trống theo mặc định là 0 (đối với số). Null cho bất kỳ đối tượng phức tạp nào, tuy nhiên, đối tượng đó không tồn tại.

Lời chào hỏi

Đối với tôi, kiểm tra tốt nhất nếu một chuỗi có bất kỳ nội dung có ý nghĩa nào trong Java là chuỗi này không:

string != null && !string.trim().isEmpty()

Trước tiên, bạn kiểm tra xem chuỗi có nulltránh không NullPointerExceptionvà sau đó bạn cắt tất cả các ký tự khoảng trắng để tránh kiểm tra các chuỗi chỉ có khoảng trắng và cuối cùng bạn kiểm tra xem chuỗi đã cắt có trống không, tức là có độ dài 0.

Tôi gặp vấn đề này trong Android và tôi sử dụng cách này (Làm việc cho tôi):

String test = null;
if(test == "null"){
// Do work
}

Nhưng trong mã java tôi sử dụng:

String test = null;
if(test == null){
// Do work
}

Và:

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
    return compareDateStrings(strDate0, strDate1);
}

private Integer compareDateStrings(String strDate0, String strDate1) {
    int cmp = 0;
    if (isEmpty(strDate0)) {
        if (isNotEmpty(strDate1)) {
            cmp = -1;
        } else {
            cmp = 0;
        }
    } else if (isEmpty(strDate1)) {
        cmp = 1;
    } else {
        cmp = strDate0.compareTo(strDate1);
    }
    return cmp;
}

private boolean isEmpty(String str) {
    return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
    return !isEmpty(str);
}

Tôi thích sử dụng:

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
    // do something
}

Đọc StringUtils.isBlank () so với String.isEmpty () .

Trong Android, bạn có thể kiểm tra điều này bằng phương pháp tiện ích isEmptytừ TextUtils,

public static boolean isEmpty(CharSequence str) {
    return str == null || str.length() == 0;
}

isEmpty(CharSequence str)phương pháp kiểm tra cả điều kiện, cho nullvà chiều dài.

Tôi luôn luôn sử dụng như thế này:

if (mystr != null && !mystr.isEmpty()){
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}

hoặc bạn có thể sao chép nó vào dự án của bạn:

private boolean isEmptyOrNull(String mystr){
    if (mystr != null && !mystr.isEmpty()){ return true; }
    else { return false; }
}

và chỉ gọi nó như:

boolean b = isEmptyOrNull(yourString);

nó sẽ trả về true nếu trống hoặc null.
b=truenếu trống hoặc null

hoặc bạn có thể sử dụng thử bắt và bắt khi nó là null.

Tôi nghĩ rằng myString không phải là một chuỗi mà là một chuỗi các chuỗi. Dưới đây là những gì bạn cần làm:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}

Bạn có thể kiểm tra chuỗi bằng null bằng cách này:

String Test = null;
(Test+"").compareTo("null")

Nếu kết quả là 0 thì (Test + "") = "null".

Tôi đã thử hầu hết các ví dụ được đưa ra ở trên cho một null trong một ứng dụng Android tôi đang xây dựng và IT ALL FAILED. Vì vậy, tôi đã đưa ra một giải pháp làm việc bất cứ lúc nào cho tôi.

String test = null+"";
If(!test.equals("null"){
       //go ahead string is not null

}

Vì vậy, chỉ cần nối chuỗi rỗng như tôi đã làm ở trên và kiểm tra chống lại "null" và nó hoạt động tốt. Trong thực tế không có ngoại lệ được ném

Ngoại lệ cũng có thể giúp:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}

Nếu bạn đang làm việc trong Android thì bạn có thể sử dụng lớp TextUtils đơn giản. Kiểm tra mã sau đây:

if(!TextUtils.isEmpty(myString)){
 //do something
}

Đây là cách sử dụng mã đơn giản. Câu trả lời có thể được lặp đi lặp lại. Nhưng là đơn giản để có kiểm tra đơn và đơn giản cho bạn.

Bạn phải kiểm tra với null if(str != null).