मैं अपनी स्ट्रिंग तुलना केस असंवेदनशील कैसे बना सकता हूं?

Question

मैंने दो तारों की तुलना करने के लिए एक जावा प्रोग्राम बनाया:

String s1 = "Hello"; 
String s2 = "hello"; 

if (s1.equals(s2)) { 
    System.out.println("hai"); 
} else { 
    System.out.println("welcome"); 
} 

यह "स्वागत" प्रदर्शित करता है। मैं समझता हूं कि यह मामला संवेदनशील है। लेकिन मेरी समस्या यह है कि मैं बिना किसी संवेदनशीलता के दो तारों की तुलना करना चाहता हूं। अर्थात। मैं आउटपुट hai होने की उम्मीद करता हूं।

Answer 1

उपयोग String.equalsIgnoreCase()

उपयोग जावा API संदर्भ इस तरह के उत्तर खोजने के लिए।

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

http://java.sun.com/j2se/1.5.0/docs/api/

Answer 2

• सबसे अच्छा s1.equalsIgnoreCase(s2) का उपयोग करेंगे: (javadoc देखें)
• तुम भी उन दोनों ऊपरी/निचले मामले में बदल सकते हैं और प्रयोग s1.equals(s2)

Answer 3

s1.equalsIgnoreCase (s2)
का उपयोग करें http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.Object)

Answer 4

आप उपयोग कर सकते हैं equalsIgnoreCase

Answer 5

स्ट्रिंग के बारे में अधिक String Class और String Tutorials

Answer 6

में पाया जा सकता है आप String वस्तु की compareToIgnoreCase विधि का उपयोग करने के लिए है।

int compareValue = str1.compareToIgnoreCase(str2); 

if (compareValue == 0) इसका मतलब है str1 के बराबर होती है str2।

Answer 7

ध्यान दें कि आप अपने .equals या .equalsIgnoreCase करने से पहले भी उन पर शून्य जांच करना चाह सकते हैं।

एक शून्य स्ट्रिंग ऑब्जेक्ट एक बराबर विधि को कॉल नहीं कर सकता है।

अर्थात्:

public boolean areStringsSame(String str1, String str2) 
{ 
    if (str1 == null && str2 == null) 
     return true; 
    if (str1 == null || str2 == null) 
     return false; 

    return str1.equalsIgnoreCase(str2); 
} 

Answer 8

डिफ़ॉल्ट जावा एपीआई में आप हैं:

String.CASE_INSENSITIVE_ORDER 

तो तुम एक तुलनित्र के पुनर्लेखन के लिए आप छाँटे गए डेटा संरचनाओं के साथ तार का उपयोग करने के लिए गए थे, तो जरूरत नहीं है।

String s = "some text here"; 
s.equalsIgnoreCase("Some text here"); 

क्या आप अपने कोड में शुद्ध समानता जांच के लिए चाहते हैं।

जावा में स्ट्रिंग्स की समानता से संबंधित किसी भी चीज़ के बारे में और जानकारी के लिए बस। java.lang.String वर्ग के hashCode() फ़ंक्शन "केस संवेदी है":

public int hashCode() { 
    int h = hash; 
    if (h == 0 && value.length > 0) { 
     char val[] = value; 

     for (int i = 0; i < value.length; i++) { 
      h = 31 * h + val[i]; 
     } 
     hash = h; 
    } 
    return h; 
} 

तो तुम कुंजी के रूप में तार के साथ एक Hashtable/HashMap उपयोग करने के लिए, और "SomeKey" की तरह कुंजी चाहते हैं, तो " सोमेकी "और" कुछकी "को बराबर के रूप में देखा जाना चाहिए, तो आपको अपनी स्ट्रिंग को किसी अन्य वर्ग में लपेटना होगा (आप स्ट्रिंग का विस्तार नहीं कर सकते क्योंकि यह अंतिम श्रेणी है)।उदाहरण के लिए:

private static class HashWrap { 
    private final String value; 
    private final int hash; 

    public String get() { 
     return value; 
    } 

    private HashWrap(String value) { 
     this.value = value; 
     String lc = value.toLowerCase(); 
     this.hash = lc.hashCode(); 
    } 

    @Override 
    public boolean equals(Object o) { 
     if (this == o) return true; 
     if (o instanceof HashWrap) { 
      HashWrap that = (HashWrap) o; 
      return value.equalsIgnoreCase(that.value); 
     } else { 
      return false; 
     } 
    } 

    @Override 
    public int hashCode() { 
     return this.hash; 
    } 
} 

और उसके बाद यह इस तरह के रूप में उपयोग:

HashMap<HashWrap, Object> map = new HashMap<HashWrap, Object>(); 

Answer 9

public boolean newEquals(String str1, String str2) 
{ 
    int len = str1.length(); 
int len1 = str2.length(); 
if(len==len1) 
{ 
    for(int i=0,j=0;i<str1.length();i++,j++) 
    { 
     if(str1.charAt(i)!=str2.charAt(j)) 
     return false; 
    }`enter code here` 
} 
return true; 
} 

Answer 10

import java.lang.String; //contains equalsIgnoreCase() 
/* 
* 
*/ 
String s1 = "Hello"; 
String s2 = "hello"; 

if (s1.equalsIgnoreCase(s2)) { 
System.out.println("hai"); 
} else { 
System.out.println("welcome"); 
} 

अब यह होगा उत्पादन: hai

Answer 11

String.equalsIgnoreCase अनुभवहीन केस के लिए सबसे अधिक व्यावहारिक विकल्प है असंवेदनशील स्ट्रिंग तुलना।

हालांकि, यह जानना अच्छा है कि यह विधि न तो पूर्ण केस फोल्डिंग और न ही अपघटन करता है और इसलिए यूनिकोड मानक में निर्दिष्ट के रूप में बेकार मिलान नहीं कर सकता है। असल में, जेडीके एपीआई केस फोल्डिंग कैरेक्टर डेटा के बारे में जानकारी तक पहुंच प्रदान नहीं करते हैं, इसलिए यह नौकरी सबसे अच्छी कोशिश की गई और परीक्षण की गई तीसरी पार्टी लाइब्रेरी में दी जाती है। ऊपरी या लोवरकेस तारों पर

import com.ibm.icu.text.Normalizer2; 

// ... 

public static boolean equalsIgnoreCase(CharSequence s, CharSequence t) { 
    Normalizer2 normalizer = Normalizer2.getNFKCCasefoldInstance(); 
    return normalizer.normalize(s).equals(normalizer.normalize(t)); 
} 

String brook = "flu\u0308ßchen"; 
    String BROOK = "FLÜSSCHEN"; 

    assert equalsIgnoreCase(brook, BROOK); 

String.equalsIgnoreCase साथ अनुभवहीन तुलना, या String.equals:

पुस्तकालय ICU है, और यहाँ कि कैसे एक केस-संवेदी स्ट्रिंग तुलना के लिए एक उपयोगिता को लागू कर सकता है यह सरल परीक्षण भी विफल हो जाएगा।

(नोट करें कि हालांकि पूर्वनिर्धारित मामले स्वाद getNFKCCasefoldInstance तह स्थान-स्वतंत्र है,। एक छोटे से अधिक काम UCharacter.foldCase शामिल तुर्की स्थानों के लिए आवश्यक हो सकता है)

Answer 12

nullsafe होने के लिए, आप उपयोग कर सकते

org.apache.commons.lang.StringUtils.equalsIgnoreCase(String, String) 

या

org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence)