ऐरेलिस्ट तत्व केस-असंवेदनशील

Question

मेरे जावा एप्लिकेशन में मुझे दो सूची के तत्व की तुलना करने की आवश्यकता है चाहे वह समान है या नहीं।

कम मान लीजिए में मैं दो सूची घोषित की है नीचे

List<String> a = new ArrayList<String>(); 
    a.add("one"); 
    a.add("three"); 
    a.add("two"); 
Collections.sort(a); 


List<String> a1 = new ArrayList<String>(); 
    a1.add("ONE"); 
    a1.add("two"); 
    a1.add("THREE"); 
Collections.sort(a); 

से पता चला की तरह अगर मैं एक शर्त समानता के लिए यह विफल लिखने के रूप में सूची के तत्व से कुछ की तरह

if(a.equals(a1)){ 
    System.out.println("equal"); 
} else{ 
    System.out.println("not equal"); 
} 

यह होगा अलग मामले में है प्रदर्शन परिणाम "बराबर नहीं"

तो कृपया मुझे बताएं कि मैं केवल जावा भाषा में सूची तत्व केस-असंवेदनशील कैसे बना सकता हूं।

धन्यवाद और संबंध

Answer 1

क्यों एक मामले असंवेदनशील तुलनित्र के साथ बजाय एक SortedSet का उपयोग नहीं? String.CASE_INSENSITIVE_ORDER तुलनित्र

अपने कोड के साथ किसी भी मुद्दे

संपादित टिप्पणियों के अनुसार संशोधित बिना

Set<String> a = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); 
    a.add("one"); 
    a.add("three"); 
    a.add("two"); 


Set<String> a1 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); 
    a1.add("ONE"); 
    a1.add("two"); 
    a1.add("THREE"); 

और अपने बराबरी की स्थिति काम करना चाहिए करने के लिए कम है। आप सभी को सही करने के लिए धन्यवाद।

Answer 2

आपको लगता है कि मैन्युअल रूप से करना होगा: मामले की अनदेखी सॉर्ट करने के लिए

public boolean equalsIgnoreCase(List<String> l1, List<String> l2) { 
    if (l1.size() != l2.size()) { 
    return false; 
    } 
    Iterator<String> i1=l1.iterator(); 
    Iterator<String> i2=l2.iterator(); 
    while(i1.hasNext()) { 
    if (!i1.next().equalsIgnoreCase(i2.next()) { 
     return false; 
    } 
    } 
    return true; 
} 

Answer 3

आप क्रम में

Collections.sort(a, String.CASE_INSENSITIVE_ORDER); 

उपयोग करने की आवश्यकता है, तो आप उपयोग कर सकते हैं equalsIgnoreCase मूल्यों की तुलना करने के लिए स्ट्रिंग पर विधि

आप निश्चित रूप से अपना स्वयं का केसइन्स बना सकते हैं ensitiveList क्लास, हमारे पास एक CaseInsensitiveSet & हमारे कोडबेस

Answer 4

में केसइन्सेंसिवैप है, आपको सूची में बराबर() विधि को ओवरराइड करने की आवश्यकता होगी ताकि यह वही हो जो आप चाहते हैं। वर्तमान ArrayList.equals() पर एक नज़र डालें और इसे अनुकूलित करें ताकि यह बराबर() के बराबर इग्नोरकेज़ के साथ तुलना करता है।

Answer 5

तुम भी एक सहायक वर्ग में अपने स्ट्रिंग लपेटो और लागू के बराबर होती है & इसके लिए तरीकों की तुलना कर सकते हैं।

public class StringWrapper implements Comparable<StringWrapper> { 
    private String value; 

    StringWrapper(Strig value) { 
     this.value = value; 
    } 

    @Override boolean equals(Object o) { 
     returns String.CASE_INSENSITIVE_ORDER.equals(
      (StringWrapper) o).value 
      this.value); 
    } 

    @Override int compareTo(StringWrapper sw) { 
     returns String.CASE_INSENSITIVE_ORDER.compare(
      this.value 
      sw.value);   
    } 

    @Override String toString() { 
     return this.value; 
    } 

    @Override int hashCode() { 
     return this.value.toLowerCase.hashCode(); 
    } 
} 

And then : 

List<StringWrapper> a = new ArrayList<StringWrapper>(); 
    a.add(StringWrapper("one")); 
    a.add(StringWrapper("TWO")); 
    a.add(StringWrapper("three")); 
Collections.sort(a); 

Answer 6

आप जिस सूची का उपयोग कर रहे हैं उसमें एक रैपर वर्ग लिखने के बारे में, यह तत्वों के असंगत भंडारण से बचने के लिए बच जाएगा। http://download-llnw.oracle.com/javase/6/docs/api/java/lang/String -

public class CaseInsensitiveStringList extends ArrayList<String> { 

    @Override 
    public void add(final int index, final String element) { 
     super.add(index, element.toLowerCase()); 
    } 

    @Override 
    public boolean add(final String o) { 
     return super.add(o.toLowerCase()); 
    } 

    @Override 
    public boolean addAll(final Collection<? extends String> c) { 
     final ArrayList<String> temp = new ArrayList<String>(c.size()); 
     for (final String s : c) { 
      temp.add(s.toLowerCase()); 
     } 
     return super.addAll(temp); 
    } 

    @Override 
    public boolean addAll(final int index, final Collection<? extends String> c) { 
     final ArrayList<String> temp = new ArrayList<String>(c.size()); 
     for (final String s : c) { 
      temp.add(s.toLowerCase()); 
     } 
     return super.addAll(index, temp); 
    } 
} 

Answer 7

अनदेखी मामले

Arrays.sort(myArray, Collator.getInstance());