จะตรวจสอบได้อย่างไรว่าสตริงของฉันเท่ากับโมฆะ?

ฉันต้องการดำเนินการบางอย่างเฉพาะในกรณีที่สตริงของฉันมีค่าที่มีความหมาย ดังนั้นฉันจึงลองทำสิ่งนี้

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

และนี่

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

และนี่

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

และนี่

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

และนี่

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

และในทุกกรณีโปรแกรมของฉันdoSomethingทั้งๆที่ความจริงที่ว่าสตริงของฉันว่างเปล่า nullมันเท่ากับ ดังนั้นมีอะไรผิดปกติกับที่?

เพิ่ม:

ฉันพบสาเหตุของปัญหา ตัวแปรถูกประกาศเป็นสตริงและด้วยเหตุนี้การnullกำหนดให้กับตัวแปรนี้จึงถูกเปลี่ยนเป็น"null"! ดังนั้นใช้if (!myString.equals("null"))งานได้

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

ในฐานะที่เป็นความคิดเห็นเพิ่มเติมคุณควรตระหนักถึงคำนี้ในequalsสัญญา:

จากObject.equals(Object):

สำหรับค่าอ้างอิงใด ๆ ที่ไม่ใช่ null x, ควรx.equals(null)return false

วิธีการเปรียบเทียบกับnullคือการใช้และx == nullx != null

นอกจากนี้x.fieldและx.method()พ่นถ้าNullPointerExceptionx == null

ถ้าmyStringเป็นnullเช่นนั้นการโทรmyString.equals(null)หรือmyString.equals("")จะล้มเหลวด้วยNullPointerExceptionจะล้มเหลวด้วยคุณไม่สามารถเรียกเมธอดอินสแตนซ์ใด ๆ กับตัวแปร null ได้

ตรวจสอบ null ก่อนเช่นนี้:

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

สิ่งนี้ใช้การประเมินการลัดวงจรเพื่อไม่พยายาม.equalsถ้าmyStringล้มเหลวในการตรวจสอบโมฆะ

Apache Commons StringUtils.isNotEmptyเป็นวิธีที่ดีที่สุด

ถ้า myString เป็นจริงแล้วการเรียกการอ้างอิงใด ๆ จะล้มเหลวด้วย Null Pointer Exception (NPE) ตั้งแต่ java 6 ให้ใช้#isEmptyแทนการตรวจสอบความยาว (ในกรณีใด ๆ ไม่ควรสร้างสตริงว่างใหม่พร้อมเช็ค)

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

บังเอิญถ้าเปรียบเทียบกับตัวอักษรสตริงที่คุณทำจะย้อนกลับคำสั่งเพื่อที่จะไม่ต้องมีการตรวจสอบเป็นโมฆะคือ

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

แทน :

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

ทำงาน !!!!

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

คุณต้องตรวจสอบว่าmyStringวัตถุคือnull:

if (myString != null) {
    doSomething
}

ถ้าสายของคุณเป็นโมฆะการเรียกแบบนี้ควรจะเป็น NullReferenceException:

myString.equals (null)

แต่อย่างไรก็ตามฉันคิดว่าวิธีการเช่นนี้คือสิ่งที่คุณต้องการ:

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

จากนั้นในรหัสของคุณคุณสามารถทำสิ่งนี้:

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

ฉันขอแนะนำให้ใช้โปรแกรมอรรถประโยชน์ที่มีอยู่หรือสร้างวิธีการของคุณเอง:

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

จากนั้นใช้เมื่อคุณต้องการ:

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

ดังที่ระบุไว้ข้างต้น | | และ && ผู้ประกอบการลัดวงจร ซึ่งหมายความว่าทันทีที่พวกเขาสามารถกำหนดค่าของพวกเขาหยุด ดังนั้นถ้า (string == null) เป็นจริงส่วนความยาวไม่จำเป็นต้องถูกประเมินเนื่องจากนิพจน์จะเป็นจริงเสมอ เช่นเดียวกันกับ && โดยที่หากด้านซ้ายเป็นเท็จการแสดงออกจะเป็นเท็จเสมอและไม่จำเป็นต้องได้รับการประเมินเพิ่มเติม

ในฐานะโน้ตเพิ่มเติมการใช้ความยาวโดยทั่วไปเป็นแนวคิดที่ดีกว่าการใช้. equals ประสิทธิภาพจะดีขึ้นเล็กน้อย (ไม่มาก) และไม่ต้องการการสร้างวัตถุ (แม้ว่าคอมไพเลอร์ส่วนใหญ่อาจปรับให้เหมาะสม)

ลอง,

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

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

        // your magic here

 }

ในกรณีที่คุณทำการจัดการกับสตริงมากมีคลาส Spring ที่ยอดเยี่ยมพร้อมวิธีการที่มีประโยชน์มากมาย:

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

ทุกครั้งที่ฉันต้องจัดการกับสตริง (เกือบทุกครั้ง) ฉันหยุดและสงสัยว่าวิธีใดเป็นวิธีที่เร็วที่สุดในการตรวจสอบสตริงว่างเปล่า แน่นอนว่า string.Length == 0 การตรวจสอบควรเป็นวิธีที่เร็วที่สุดเนื่องจากความยาวเป็นคุณสมบัติและไม่ควรมีการประมวลผลใด ๆ นอกเหนือจากการดึงค่าของคุณสมบัติ แต่ฉันถามตัวเองแล้วทำไมถึงมีสตริง มันควรจะเร็วกว่าที่จะตรวจสอบ String.Empty กว่าความยาวฉันบอกตัวเอง ดีฉัน finnaly ตัดสินใจที่จะทดสอบ ฉันเขียนรหัสแอป Windows Console ขนาดเล็กที่บอกฉันว่าใช้เวลานานแค่ไหนในการตรวจสอบบางรายการสำหรับ 10 ล้านครั้ง ฉันตรวจสอบ 3 สายที่ต่างกัน: สตริง NULL, สตริงว่างและสตริง "" ฉันใช้ 5 วิธีที่แตกต่าง: 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

จากผลลัพธ์เหล่านี้การตรวจสอบโดยเฉลี่ยสำหรับstr == nullวิธีที่เร็วที่สุด แต่อาจไม่ได้ผลตามที่เราต้องการ if str = String.Emptyหรือstr = ""ผลลัพธ์เป็นเท็จ จากนั้นคุณมี 2 ที่ถูกผูกไว้ในที่สองString.IsNullOrEmpty()และstr == null || str.length == 0และเนื่องจากString.IsNullOrEmpty()ดูดีกว่าและง่ายกว่า (และเร็วกว่า) ในการเขียนฉันขอแนะนำให้ใช้กับโซลูชันอื่น

ฉันจะทำสิ่งนี้:

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

• การทดสอบ null จะตรวจสอบว่า myString มีตัวอย่างของ String หรือไม่
• length () ส่งคืนความยาวและเทียบเท่ากับเท่ากับ ("")
• ตรวจสอบว่า myString เป็นโมฆะก่อนจะหลีกเลี่ยง NullPointerException

ฉันใช้ StringUtil.isBlank(string)

มันทดสอบว่าสตริงว่างเปล่า: null, emtpy หรือช่องว่างเท่านั้น

ดังนั้นอันนี้ดีที่สุดจนถึง

นี่คือวิธีการดั้งเดิมจากเอกสาร

/**
    * 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;
    } 

สิ่งนี้น่าจะใช้ได้:

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

ถ้าไม่เช่นนั้น myString จะมีค่าที่คุณไม่ได้คาดหวัง ลองพิมพ์ด้วยวิธีนี้:

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

การใช้สัญลักษณ์ '+' เพื่อล้อมรอบสตริงจะแสดงให้คุณเห็นหากมีพื้นที่ว่างในนั้นที่คุณไม่ได้ทำบัญชี

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

โอเคนี่เป็นวิธีที่ประเภทข้อมูลทำงานใน Java (คุณต้องยกโทษให้ภาษาอังกฤษของฉันฉันเป็น prob ไม่ใช้คำศัพท์ที่ถูกต้องคุณต้องแยกความแตกต่างระหว่างสองของพวกเขา datatypes ฐานและ datatypes ปกติประเภทฐานข้อมูลสวยมากทำทุกอย่างที่มีอยู่ตัวอย่างเช่นมี คือตัวเลขทั้งหมดอักขระถ่านบูลีนเป็นต้นชนิดข้อมูลปกติหรือชนิดข้อมูลที่ซับซ้อนนั้นเป็นอย่างอื่นสตริงเป็นอาร์เรย์ของตัวอักษรดังนั้นจึงเป็นชนิดข้อมูลที่ซับซ้อน

ตัวแปรทุกตัวที่คุณสร้างนั้นเป็นตัวชี้ค่าในหน่วยความจำของคุณ ตัวอย่างเช่น:

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

ตัวแปร "s" ไม่มีสตริง มันเป็นตัวชี้ ตัวชี้นี้ชี้ไปที่ตัวแปรในหน่วยความจำของคุณ เมื่อคุณเรียกSystem.out.println(anyObject)ใช้toString()เมธอดของวัตถุนั้นจะถูกเรียก ถ้ามันไม่ได้แทนที่toStringจากวัตถุมันจะพิมพ์ตัวชี้ ตัวอย่างเช่น:

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

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

ทุกอย่างที่อยู่ด้านหลัง "@" เป็นตัวชี้ ใช้งานได้กับประเภทข้อมูลที่ซับซ้อนเท่านั้น ประเภทข้อมูลดั้งเดิมจะถูกบันทึกโดยตรงในตัวชี้ของพวกเขา ดังนั้นจริงๆแล้วไม่มีตัวชี้และค่าจะถูกเก็บไว้โดยตรง

ตัวอย่างเช่น:

int i = 123;

ฉันไม่ได้เก็บตัวชี้ไว้ในกรณีนี้ ฉันจะเก็บค่าจำนวนเต็ม 123 (เป็นไบต์ ofc)

โอเคลองกลับมาที่ ==ผู้ควบคุม มันจะเปรียบเทียบตัวชี้เสมอและไม่ใช่เนื้อหาที่บันทึกไว้ที่ตำแหน่งของตัวชี้ในหน่วยความจำ

ตัวอย่าง:

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

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

>>>>> false

ทั้งสองนี้มีตัวชี้ที่แตกต่างกัน String.equals (String อื่น ๆ ) อย่างไรก็ตามเปรียบเทียบเนื้อหา คุณสามารถเปรียบเทียบชนิดข้อมูลดั้งเดิมกับตัวดำเนินการ '==' ได้เนื่องจากตัวชี้ของวัตถุที่แตกต่างกันสองชนิดที่มีเนื้อหาเดียวกันเท่ากัน

Null จะหมายความว่าตัวชี้นั้นว่างเปล่า ชนิดข้อมูลดั้งเดิมที่ว่างเปล่าโดยค่าเริ่มต้นคือ 0 (สำหรับตัวเลข) ว่างเปล่าสำหรับวัตถุที่ซับซ้อนใด ๆ อย่างไรก็ตามหมายความว่าวัตถุนั้นไม่มีอยู่

ทักทาย

สำหรับฉันการตรวจสอบที่ดีที่สุดถ้าสตริงมีเนื้อหาที่มีความหมายใน Java คืออันนี้:

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

ก่อนอื่นให้คุณตรวจสอบว่าสายอักขระนั้นnullควรหลีกเลี่ยงหรือไม่NullPointerExceptionจากนั้นคุณตัดแต่งอักขระช่องว่างทั้งหมดเพื่อหลีกเลี่ยงการตรวจสอบสายอักขระที่มีเพียงช่องว่างและสุดท้ายคุณตรวจสอบว่าสายอักขระที่ตัดแต่งไม่ว่างเปล่านั่นคือความยาว 0

ฉันมีปัญหานี้ใน Android และฉันใช้วิธีนี้ (ทำงานให้ฉัน):

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

แต่ในรหัส java ฉันใช้:

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

และ:

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);
}

ฉันชอบที่จะใช้:

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

อ่านStringUtils.isBlank () VS String.isEmpty ()

ใน Android คุณสามารถตรวจสอบเรื่องนี้ด้วยวิธียูทิลิตี้isEmptyจากTextUtils,

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

isEmpty(CharSequence str)ตรวจสอบวิธีการทั้งเงื่อนไขสำหรับnullและความยาว

ฉันมักจะใช้สิ่งนี้:

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

หรือคุณสามารถคัดลอกสิ่งนี้ไปยังโครงการของคุณ:

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

และเพียงแค่เรียกมันว่า:

boolean b = isEmptyOrNull(yourString);

มันจะกลับมาจริงถ้าว่างเปล่าหรือเป็นโมฆะ
b=trueถ้าว่างเปล่าหรือว่างเปล่า

หรือคุณสามารถใช้ลองจับและจับเมื่อมันเป็นโมฆะ

ฉันคิดว่า myString ไม่ใช่สตริง แต่เป็นอาร์เรย์ของสตริง นี่คือสิ่งที่คุณต้องทำ:

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

คุณสามารถตรวจสอบสตริงเท่ากับ null โดยใช้สิ่งนี้:

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

ถ้าผลลัพธ์เป็น 0 ดังนั้น (ทดสอบ + "") = "null"

ฉันลองตัวอย่างส่วนใหญ่ที่ระบุด้านบนเพื่อหาค่า null ในแอพ android l กำลังสร้างและมันล้มเหลว ดังนั้นฉันจึงคิดวิธีแก้ปัญหาที่ทำงานได้ตลอดเวลาสำหรับฉัน

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

}

ดังนั้นเพียงแค่เชื่อมสตริงว่างเปล่าเช่นเดียวกับที่ได้ทำข้างบนและทดสอบกับ "null" และทำงานได้ดี ในความเป็นจริงไม่มีข้อยกเว้นถูกโยน

ข้อยกเว้นอาจช่วย:

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

หากคุณทำงานใน Android คุณสามารถใช้คลาส TextUtils แบบง่าย ๆ ได้ ตรวจสอบรหัสต่อไปนี้:

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

นี่เป็นการใช้รหัสอย่างง่าย คำตอบอาจถูกทำซ้ำ แต่ง่ายต่อการตรวจสอบเพียงครั้งเดียวและง่ายสำหรับคุณ

คุณต้องตรวจสอบด้วย null if(str != null).