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

111

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

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

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

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

java  string  comparison  case-insensitive 
— user268018
स्रोत
3
यदि आप जानते हैं कि यह मामला संवेदनशील है, तो आप तुलना करने से पहले लोअरकेस या अपरकेस दोनों में बदल सकते हैं।
— fastcodejava
यदि आप उपयोग करते s1.equalsIgnoreCase(s2)हैं तो आप इसे हर जगह करने में विफल हो सकते हैं, इसे करने की आवश्यकता है। मेरा सुझाव है कि आप पाते हैं कि स्ट्रिंग कहाँ से आती है - एक फ़ाइल या डेटाबेस या उपयोगकर्ता इनपुट शायद - और या तो अपरकेस (या लोअरकेस) में कनवर्ट करें और तुलना के लिए।
— H2ONaCl
2
निम्न / अपरकेस में परिवर्तित न करें (जैसा कि ऊपर टिप्पणियों द्वारा सुझाया गया है), स्वीकृत equalsIgnoreCaseदृष्टिकोण का उपयोग करें । तुर्की I समस्या और इसी तरह के यूनिकोड मुद्दों पर तर्क के लिए पढ़ें।
— ओहद श्नाइडर
1
@OhadSchneider equalsIgnoreCaseवैसे भी तुर्की के लिए गलत मान लौटाता है, क्योंकि यह "i" और "I" की तुलना करने के लिए सही है, भले ही यह गलत वापस आ जाए। इसलिए मुझे संदेह है कि यदि आप स्थानों को ध्यान में रखना चाहते हैं, Collatorतो वास्तव में जाने का रास्ता है।
— तर्जुक
1
@OhadSchneider मुझे आश्चर्य है। यह कहता है कि इसे प्रति-चरित्र करने से एक ही परिणाम उत्पन्न होता है, लेकिन पूरे स्ट्रिंग पर toLowerCase/ toUpperCaseकरना और इसे प्रति-चरित्र करना दो अलग परिणाम देता है।
— ट्रेकजाज़

जवाबों:

171
  • सबसे अच्छा उपयोग किया जाएगा s1.equalsIgnoreCase(s2): ( javadoc देखें )
  • आप उन्हें ऊपरी / निचले मामले और उपयोग दोनों में परिवर्तित कर सकते हैं s1.equals(s2)
— माइकल बाविन
स्रोत
39
बस ध्यान रखें कि दो समाधान सभी स्थानों के लिए समान नहीं हैं। स्ट्रिंग # equalsIgnoreCase स्थानीय विशिष्ट आवरण नियमों का उपयोग नहीं कर रहा है, जबकि स्ट्रिंग #LowerCase और #toUpperCase करते हैं।
— जर्बंजो
1
क्या आप उस अंतर के लिए एक उदाहरण दे सकते हैं?
— टावी
16
स्थानीय विशिष्ट मामले के नियम कम से कम तुर्की और जर्मन के लिए लागू किए गए हैं। तुर्की मैं के साथ और बिना डॉट के दो अलग-अलग अक्षरों के रूप में व्यवहार करता हूं, निचले / ऊपरी केस जोड़े i और ıI का निर्माण करता है जबकि अन्य भाषाएं iI को एक जोड़ी के रूप में मानते हैं और पत्र ı और İ का उपयोग नहीं करते हैं। जर्मन में, निचले मामले को "एसएस" के रूप में कैपिटल किया जाता है।
— जरबजो
24

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ऊपरी- या निचले स्तर पर तार की तुलना में यह सरल परीक्षण भी विफल हो जाएगा।

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

— glts
स्रोत
22

आपको ऑब्जेक्ट की compareToIgnoreCaseविधि का उपयोग करना होगा String।

int compareValue = str1.compareToIgnoreCase(str2);

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

— Aliti
स्रोत
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

— KNU
स्रोत
5

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

String.CASE_INSENSITIVE_ORDER

यदि आपको सॉर्टेड डेटा संरचनाओं के साथ स्ट्रिंग्स का उपयोग करना था, तो आपको एक तुलनित्र को फिर से लिखने की आवश्यकता नहीं है।

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

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

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

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

इसलिए यदि आप स्ट्रिंग्स के साथ एक हैशटेबल / हैशपॉप को कुंजियों के रूप में उपयोग करना चाहते हैं, और "SomeKey", "SOMEKEY" और "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>();
— le-Doude
स्रोत
2

ध्यान दें कि आप उन पर और साथ ही अपने।

एक अशक्त स्ट्रिंग ऑब्जेक्ट एक समान विधि नहीं कह सकता।

अर्थात:

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);
}
— VeenarM
स्रोत
1
नोट: दूसरे दो बयानों को इस तरह एक ही परिणाम बनाने के लिए जोड़ा जा सकता है if (str1 == null || str2 == null) return false;:।
— लकीमे
उपरोक्त टिप्पणी के अनुसार संशोधित होने के लिए संशोधित कोड - लंबा दिन था :)
— VeenarM
1
आप पहली पंक्ति को भी बदल सकते हैं if (str1 == str2) return true;जिसमें दोनों नल के लिए पूरा करता है और उस मामले को भी शॉर्टकट करता है जहां दो स्ट्रिंग संदर्भ एक ही स्ट्रिंग ऑब्जेक्ट को संदर्भित करते हैं।
— बार्नी
1

अशक्त होने के लिए, आप उपयोग कर सकते हैं

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

या

org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence)
— brandstaetter
स्रोत
-6 
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;
}
— javacoder
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.