यदि मेरा स्ट्रिंग अशक्त के बराबर है तो कैसे जांचें?

Question

मैं केवल कुछ कार्रवाई करना चाहता हूं यदि मेरे स्ट्रिंग का सार्थक मूल्य है। इसलिए, मैंने यह कोशिश की।

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"))काम करता है।

Comments

nullकोई विधि नहीं है, इसलिए भी नहीं equals()। यदि myStringथे null, तो आप कभी इस पर एक विधि कैसे लागू करेंगे? :)

— BalusC

क्या मैं आपको सुझाव दूंगा कि System.out.println(myString)यदि आप तुरंत ब्लॉक से पहले आप देख सकते हैं कि वहां क्या है?

— माइकल मायर्स

आप कैसे जानते हैं कि "यह बराबर है null"?

— रिचर्ड जेपी ले गुएन

nullइस चर को सौंपा "null"- यह एक भयानक विचार है। यदि संभव हो तो इस डिज़ाइन को बदलने का प्रयास करें।

— पॉलीजेन लुब्रीकेंट

Yuck - मुझे नहीं लगता कि जाँच (क्या! MyString.equals ("null")) सबसे अच्छा समाधान है। मुझे संदेह है कि अधिकांश उस बिंदु पर विचार करेंगे जिस पर स्ट्रिंग "अशक्त" को एक बग होने के लिए myString को सौंपा गया था।

— बर्ट एफ

Answer 1

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

---

आगे की टिप्पणी के रूप में, आपको equalsअनुबंध में इस शब्द के बारे में पता होना चाहिए :

से Object.equals(Object):

किसी भी गैर-शून्य संदर्भ मूल्य के लिए x, x.equals(null)चाहिए return false।

तुलना करने का तरीका nullउपयोग करना है x == nullऔर x != null।

इसके अलावा, x.fieldऔर अगर x.method()फेंकता NullPointerExceptionहै x == null।

Comments

दक्षता उद्देश्यों के लिए बराबरी के विपरीत आपको लंबाई की जांच करनी चाहिए। इस लिंक की जाँच करें hanuska.blogspot.com/2006/08/empty-string.html

— CoolBeans

मैं कहूंगा कि आपको पठनीयता के s.isEmpty()बजाय करना चाहिए s.length() == 0। प्रदर्शन में कोई अंतर नगण्य है। मैं सहमत हूँ कि s.equals("")भयानक है।

— पॉलीजेन लुब्रीकेंट

मैं पठनीयता पर सहमत हूं। यह निर्भर करता है कि क्या हम जावा 5 बनाम जावा 6 का उपयोग कर रहे हैं क्योंकि isEmpty () केवल जावा 6 में है

— CoolBeans

@CoolBeans: अच्छी टिप्पणी! मुझे एहसास नहीं था कि! मुझे जावा पार्टी =) में थोड़ी देर हो गई है

— पॉलीजेनबेलिकेंट

Answer 2

यदि myStringहै null, तो बुला रहा है myString.equals(null)याmyString.equals("") साथ विफल हो जाएगा NullPointerException। आप अशक्त चर पर कोई इंस्टेंस विधि नहीं कह सकते।

इस तरह पहले अशक्त के लिए जाँच करें:

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

यह शॉर्ट-सर्किट मूल्यांकन का उपयोग करता है .equalsयदि myStringअशक्त जांच में विफल रहता है तो प्रयास न करें।

Comments

शॉर्ट-सर्किट के लिए +1; अभिव्यक्ति के लिए काम करना आवश्यक है। हालांकि, आपको वास्तव में .isEmpty()इसके बजाय का उपयोग करना चाहिए .equals("")।

— पॉलीजेन लुब्रीकेंट

ठीक है, मैं इस पोस्ट पर अपनी टिप्पणी छोड़ने का मतलब था। जबरदस्त हंसी। -> "आपको दक्षता के उद्देश्यों के बराबर लंबाई की जाँच करनी चाहिए। इस लिंक की जाँच करें। hanuska.blogspot.com/2006/08/empty-string.html"

— कूलबीन्स

@CoolBeans: ज़रूर, और जावा 6 के साथ आप भी कर सकते हैं myString.isEmpty()। लेकिन इस स्तर पर, पठनीयता ट्रम्प्स अनुकूलन, और लोगों को पढ़ने के लिए और अधिक उपयोग हो सकती है myString.equals("")। (या शायद नहीं।)

— माइकल मायर्स

Answer 3

अपाचे कॉमन्स जाने StringUtils.isNotEmptyका सबसे अच्छा तरीका है।

Answer 4

यदि myString वास्तव में अशक्त है, तो संदर्भ के लिए कोई भी कॉल Null Pointer Exception (NPE) के साथ विफल हो जाएगी। जावा 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();
}

Comments

अच्छी बात है, लेकिन पिछले दो अगर बराबर नहीं हैं। MyString = "abc" के साथ, बीच वाला doSomething कॉल नहीं करता, लेकिन तीसरा व्यक्ति करता है।

— रिम्स्की

@rimsky यह तय किया गया है

— pavi2410

Answer 5

काम कर रहे !!!!

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

Answer 6

आपको यह जांचना होगा कि myStringवस्तु क्या है null:

if (myString != null) {
    doSomething
}

Answer 7

यदि आपकी स्ट्रिंग अशक्त है, तो इस तरह से कॉल करने से NullReferenceException फेंकनी चाहिए:

myString.equals (शून्य)

लेकिन वैसे भी, मुझे लगता है कि इस तरह से एक विधि है जो आप चाहते हैं:

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

फिर अपने कोड में, आप इस तरह की चीजें कर सकते हैं:

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

Answer 8

मैं एक मौजूदा उपयोगिता का उपयोग करने, या अपनी खुद की विधि बनाने के लिए प्रोत्साहित करूंगा:

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

फिर ज़रूरत पड़ने पर बस इसका इस्तेमाल करें:

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

जैसा कि ऊपर उल्लेख किया है, || और && ऑपरेटर्स शॉर्ट सर्किट। इसका मतलब है कि जैसे ही वे अपने मूल्य को निर्धारित कर सकते हैं वे बंद कर देते हैं। इसलिए यदि (string == null) सत्य है, तो लंबाई वाले हिस्से का मूल्यांकन करने की आवश्यकता नहीं है, क्योंकि अभिव्यक्ति हमेशा सच होगी। इसी तरह && के साथ, जहां यदि बाईं ओर गलत है, तो अभिव्यक्ति हमेशा झूठी होती है और आगे मूल्यांकन करने की आवश्यकता नहीं होती है।

एक अतिरिक्त नोट के रूप में, लंबाई का उपयोग करना आम तौर पर उपयोग करने की तुलना में एक बेहतर विचार है। प्रदर्शन थोड़ा बेहतर है (बहुत अधिक नहीं), और इसके लिए ऑब्जेक्ट निर्माण की आवश्यकता नहीं है (हालांकि अधिकांश कंपाइलर इसे बाहर अनुकूलित कर सकते हैं)।

Answer 9

प्रयत्न,

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

Comments

यह संभव नहीं है अगर myString अशक्त है

— hsmit

यह बहुत संभव है जब myString शून्य हो। आपको पता होना चाहिए कि जब && के बाएं भाग में विफल रहता है, तो सही अभिव्यक्ति का मूल्यांकन बिल्कुल भी नहीं किया जाएगा ..

— bragboy

Answer 10

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

        // your magic here

 }

संयोग से, यदि आप बहुत स्ट्रिंग हेरफेर कर रहे हैं, तो सभी प्रकार के उपयोगी तरीकों के साथ एक महान स्प्रिंग क्लास है:

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

Answer 11

हर बार मुझे स्ट्रिंग्स से निपटना पड़ता है (लगभग हर बार) मैं रुकता हूं और आश्चर्य करता हूं कि खाली स्ट्रिंग की जांच करने के लिए कौन सा तरीका वास्तव में सबसे तेज़ तरीका है। निश्चित रूप से string.Length == 0 चेक सबसे तेज़ होना चाहिए क्योंकि लंबाई एक संपत्ति है और संपत्ति के मूल्य को पुनः प्राप्त करने के अलावा कोई प्रसंस्करण नहीं होना चाहिए। लेकिन फिर मैं खुद से पूछता हूं, एक स्ट्रिंग क्यों है। खाली? यह स्ट्रिंग के लिए जाँच करने के लिए तेज़ होना चाहिए। लंबाई की तुलना में खाली, मैं खुद को बताता हूं। खैर मैं finnaly इसे बाहर का परीक्षण करने का फैसला किया। मैंने एक छोटा विंडोज कंसोल ऐप कोड किया, जो बताता है कि 10 मिलियन रिपीटिशन के लिए एक निश्चित चेक करने में कितना समय लगता है। मैंने 3 अलग-अलग तारों की जाँच की: एक नल स्ट्रिंग, एक खाली स्ट्रिंग और एक "" स्ट्रिंग। मैंने 5 अलग-अलग तरीकों का इस्तेमाल किया: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == नल || str == "", str == अशक्त || 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()अच्छा लग रहा है और यह लिखना आसान (और तेज) है कि मैं इसे दूसरे समाधान पर उपयोग करने की सलाह दूंगा।

Answer 12

मैं ऐसा कुछ करूँगा:

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

• अशक्त जाँच के लिए परीक्षण कि क्या MyString में स्ट्रिंग का उदाहरण है।
• लंबाई () लंबाई लौटाती है और बराबर ("") के बराबर होती है।
• अगर MyString पहले null है तो जाँचना NullPointerException से बचना होगा।

Answer 13

मैं उपयोग कर रहा था StringUtil.isBlank(string)

यह जांचता है कि क्या एक स्ट्रिंग रिक्त है: अशक्त, खाली, या केवल व्हाट्सएप।

तो यह एक अब तक का सबसे अच्छा है

यहाँ डॉक्स से ओरिगनल विधि है

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

Answer 14

यह काम करना चाहिए:

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

यदि नहीं, तो myString संभावना का एक मूल्य है जिसकी आप अपेक्षा नहीं कर रहे हैं। इसे इस तरह से प्रिंट करने की कोशिश करें:

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

स्ट्रिंग को घेरने के लिए '+' प्रतीकों का उपयोग करना आपको दिखाएगा कि क्या वहां पर अतिरिक्त व्हाट्सएप है जो आप के लिए लेखांकन नहीं कर रहे हैं।

Answer 15

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

Comments

IsEmpty उलट है .. यदि आप अशक्त वस्तु पर विधि कहते हैं, तो आपको NPE

— ब्रायन

यदि स्ट्रिंग अशक्त है, तो आपको अशक्त सूचक अपवाद मिलता है, इससे पहले कि आप यह जांच लें कि यह शून्य है। इस कोड का उपयोग कभी नहीं किया जाना चाहिए!

— gil.fernandes

Answer 16

ठीक है कि यह कैसे 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 (बाइट ऑफ इनक) को स्टोर करूंगा।

ठीक है तो चलो वापस आते हैं == ऑपरेटर । यह हमेशा पॉइंटर की तुलना करता है न कि मैमोरी में पॉइंटर की स्थिति में सेव की गई सामग्री की।

उदाहरण:

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

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

>>>>> false

इस दोनों स्ट्रिंग का एक अलग सूचक है। String.equals (अन्य स्ट्रिंग) हालांकि सामग्री की तुलना करता है। आप '==' ऑपरेटर के साथ आदिम डेटा प्रकारों की तुलना कर सकते हैं क्योंकि एक ही सामग्री के साथ दो अलग-अलग वस्तुओं के सूचक बराबर हैं।

अशक्त का अर्थ होगा कि सूचक खाली है। डिफ़ॉल्ट रूप से एक खाली आदिम डेटा प्रकार 0 (संख्याओं के लिए) है। हालांकि किसी भी जटिल वस्तु के लिए अशक्त का मतलब है, वह वस्तु मौजूद नहीं है।

अभिवादन

Answer 17

मेरे लिए सबसे अच्छी जाँच है कि यदि स्ट्रिंग में जावा में कोई सार्थक सामग्री है तो यह एक है:

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

पहले आप जांच लें कि स्ट्रिंग nullसे बचना है या नहीं NullPointerExceptionऔर फिर आप सभी स्पेसिंग कैरेक्टर को ट्रिम करने से बचने के लिए ट्रिम कर लें, जिसमें केवल व्हाट्सएप हो और अंत में आप चेक करें कि ट्रिम किया गया स्ट्रिंग खाली तो नहीं है, यानी लंबाई 0 है।

Answer 18

मुझे एंड्रॉइड में यह समस्या थी और मैं इस तरह से काम करता हूं (मेरे लिए काम करें):

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

लेकिन जावा कोड में मैं उपयोग करता हूं:

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

Answer 19

मैं उपयोग करना पसंद करता हूं:

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

StringUtils.isBlank () बनाम String.isEmpty () पढ़ें ।

Answer 20

Android में आप इसकी उपयोगिता विधि isEmptyसे जांच कर सकते हैं TextUtils,

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

isEmpty(CharSequence str)विधि दोनों की स्थिति nullऔर लंबाई की जाँच करें ।

Answer 21

मैं हमेशा इस तरह का उपयोग करता हूं:

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अगर खाली है या अशक्त है

या जब आप अशक्त हों तब आप इसे पकड़ने और पकड़ने का उपयोग कर सकते हैं।

Answer 22

मुझे लगता है कि myString स्ट्रिंग नहीं बल्कि स्ट्रिंग्स की एक सरणी है। यहाँ है आपको क्या करने की जरूरत है:

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

Comments

मेरा कोड प्रोसेसिंग के लिए है। प्रसंस्करण एक जावा-आधारित प्रोग्रामिंग भाषा है। अधिक जानकारी के बारे में में शामिल होने: processing.org/reference/join_.html ।

— mimit

Answer 23

आप इसका उपयोग करके नल के बराबर स्ट्रिंग की जांच कर सकते हैं:

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

यदि परिणाम 0 है तो (टेस्ट + "") = "अशक्त"।

Comments

यह सिर्फ एक अनावश्यक स्ट्रिंग बनाता है

— svarog

Answer 24

मैंने ऊपर दिए गए अधिकांश उदाहरणों की कोशिश की, जो कि एक एंड्रॉइड ऐप एल में एक अशक्त के लिए दिए गए थे। तो l एक समाधान लेकर आया जो मेरे लिए कभी भी काम आया।

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

}

तो बस एक खाली स्ट्रिंग समतल करें जैसा कि एल ने ऊपर किया था और "नल" के खिलाफ परीक्षण किया था और यह ठीक काम करता है। वास्तव में कोई अपवाद नहीं फेंका गया है

Comments

नहीं, यह एक बहुत ही भयानक समाधान है। काम के ऊपर जवाब।

— कोनराड रुडोल्फ

@KonradRudolph मैंने अपने निष्कर्ष पर पहुंचने से पहले वास्तव में इनमें से कुछ समाधानों की कोशिश की थी। मैंने इन साइक्लोन का इस्तेमाल रिसाइकलव्यू एडॉप्टर में करने की कोशिश की और इसने मुझे सही जवाब नहीं दिया, जब तक कि l यह जवाब नहीं आया।

— leeCoder

मैं विश्वास के साथ कह सकता हूं कि इसका मतलब आपके कोड में कुछ और गड़बड़ है, और आप केवल लक्षणों को ठीक कर रहे हैं, त्रुटि का स्रोत नहीं। इसे गलत तरीके से न लें, लेकिन यह कार्गो पंथ प्रोग्रामिंग का एक विशिष्ट मामला है ।

— कोनराड रुडोल्फ

Answer 25

अपवाद भी मदद कर सकता है:

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

Answer 26

यदि आप Android में काम कर रहे हैं तो आप साधारण TextUtils वर्ग का उपयोग कर सकते हैं। निम्नलिखित कोड की जाँच करें:

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

यह कोड का सरल उपयोग है। उत्तर दोहराया जा सकता है। लेकिन आपके लिए एकल और सरल जांच करना सरल है।

Answer 27

आपको अशक्त के साथ जांचना होगा if(str != null).

Comments

आपका समाधान अन्य उपयोगकर्ताओं द्वारा वर्षों पहले पोस्ट किया गया था ... इसे दोहराने की बात क्या है?

— टीडीजी

मुझे लगता है कि मैं उसे जवाब क्यों की पुष्टि के गैर देख रहा हूँ

— 9a पर कच्चे 29and

ठीक है, उसने 2010 से उत्तरों की पुष्टि नहीं की है, इसलिए आप सिर्फ एक पिछला उत्तर दोहराएंगे और वह आपके उत्तर की पुष्टि करेगा ...

— TDG