दिलचस्प पोस्ट
किसी अन्य विधि में एक विधि के एक चर का उपयोग कैसे करें? समूह द्वारा एक स्तंभ को विभाजित करें जावास्क्रिप्ट को संसाधित करने के लिए मैकेनिक का उपयोग कैसे करूं? अजगर के अंदर से चलने वाली स्क्रिप्ट स्ट्रिंग को पायथन में लोअरकेस में कनवर्ट कैसे करें हेडर फाइलों में वैरिएबल घोषणा – स्थिर या नहीं? MySQL: पंक्तियों की संख्या को गिनने का सबसे तेज़ तरीका ASP.NET MVC में विफलता मान्यकरण के बाद इनपुट टाइप = फाइल फ़ील्ड मान कैसे रखना है? एएसपी.नेट एमवीसी 4 में कस्टम त्रुटि पेज कैसे काम करते हैं कितने धागे बहुत अधिक हैं? लॉग-आउट से एक एंड्रॉइड डिवाइस पर एसडी-कार्ड पर मेरे लॉग आउटपुट को कैसे पुनर्निर्देशित किया जाए? PHPExcel वर्ग Zend Autoloader में नहीं मिला चींटी स्थापित करने में त्रुटि: ANT_HOME गलत सेट है दिए गए HTML के साथ एक आइफ्रेम बनाना गतिशील रूप से गैलरी में एंड्रॉइड से चयनित होने पर छवि क्रॉप करें

ArrayList में केस संवेदनशीलता होती है

मैं वर्तमान में एक खोज बनाने के लिए ArrayList वर्ग से संबंधित पद्धति का उपयोग कर रहा हूं। क्या इस खोज केस को जावा में असंवेदनशील बनाने का कोई तरीका है? मुझे लगता है कि सी # में यह संभव है OrdinalIgnoreCase का उपयोग करें क्या जावा बराबर है, या ऐसा करने के लिए एक और तरीका है? धन्यवाद।

Solutions Collecting From Web of "ArrayList में केस संवेदनशीलता होती है"

आप इसका उपयोग बिल्कुल उसी तरह कर सकते हैं जैसे आप किसी भी अन्य ArrayList का उपयोग करेंगे आप इस सूची को अन्य कोड से बाहर कर सकते हैं, और बाहरी कोड को किसी भी स्ट्रिंग आवरण क्लासेस को समझने की आवश्यकता नहीं होगी।

public class CustomStringList3 extends ArrayList<String> { @Override public boolean contains(Object o) { String paramStr = (String)o; for (String s : this) { if (paramStr.equalsIgnoreCase(s)) return true; } return false; } } 

यदि आप जावा 8 का उपयोग कर रहे हैं, तो कोशिश करें:

 List<String> list = ...; String searchStr = ...; boolean containsSearchStr = list.stream().filter(s -> s.equalsIgnoreCase(searchStr)).findFirst().isPresent(); 

परंपरागत रूप से, आप एक ArrayList द्वारा आयोजित तारों की तुलना करने के लिए अपना तर्क विकसित कर सकते हैं। नीचे दिखाए गए एक जैसा ऐसा करने के कई तरीके हो सकते हैं

 public boolean containsCaseInsensitive(String strToCompare, ArrayList<String>list) { for(String str:list) { if(str.equalsIgnoreCase(strToCompare)) { return(true); } } return(false); } 

किसी तरह के अनुक्रमित तुलनित्र के साथ नीचे दिखाए गए अनुसार सॉर्टेडसेट की तरह कुछ प्रत्यक्ष और सुविधाजनक तरीके का उपयोग क्यों नहीं किया जाना चाहिए?

 Set<String> a = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); a.add("A"); a.add("B"); a.add("C"); Set<String> b = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); b.add("a"); b.add("b"); b.add("c"); System.out.println(b.equals(a)); 

दो अलग-अलग सेटों की अनदेखी करते हैं और इस बात की वापसी करते true कि इस विशेष परिस्थिति में आपकी तुलना किसी भी मुद्दे के बिना काम करेगी।

Java8 में, किसी भी मैच का उपयोग कर

 List<String> list = Arrays.asList("XYZ", "ABC"); String matchingText = "xYz"; boolean isMatched = list.stream().anyMatch(matchingText::equalsIgnoreCase); 

जावा एपीआई को देखते हुए इसमें कोई ऐसी विधि नहीं है, जिसमें शामिल हैं।

लेकिन आप कम से कम दो चीजें कर सकते हैं:

  1. अपने ArrayList ऑब्जेक्ट में अपने स्वयं के साथ बराबर विधि को ओवरराइड करें, या बराबर अनदेखा कैस (str)
  2. अपनी स्वयं की विधि लिखें, जो आपके ऐरेएलआईआईटी संस्थाओं के माध्यम से पुनरावृति करें, और मैन्युअल जांच करें।

     ArrayList<String> list = new ArrayList<String>(); ... containsIgnoreCase("a", list); public boolean containsIgnoreCase(String str, ArrayList<String> list){ for(String i : list){ if(i.equalsIgnoreCase(str)) return true; } return false; } 

मान लें कि आपके पास एक ArrayList<String>

एकमात्र तरीका मैं ऐसा करने के बारे में सोच सकता हूं कि स्ट्रिंग और ओवरराइड के बराबर एक बहुत ही हल्का आवरण वर्ग बनाना होगा और मामले को अनदेखा करने के लिए equalsIgnoreCase() करना होगा, उपेक्षा करना उपेक्षा करना equalsIgnoreCase() जहां संभव हो। तो आपके पास एक ArrayList<YourString> हालांकि यह थोड़े बदसूरत विचार है

ArrayList के पास () विधि आपके द्वारा प्रदान किए गए ऑब्जेक्ट पर बराबर () विधि को कॉल करके समानता की जांच करती है (सरणी में ऑब्जेक्ट नहीं)। इसलिए, स्ट्रिंग ऑब्जेक्ट के आस-पास एक आवरण वर्ग बनाना है, इस तरह से:

 class InsensitiveStringComparable { private final String val; public InsensitiveStringComparable(String val) { this.val = val; } @Override public boolean equals(Object x) { if (x == this) return true; else if (x == null) return false; else if (x instanceof InsensitiveStringComparable) return ((InsensitiveStringComparable) x).val.equalsIgnoreCase(val); else if (x instanceof String) /* Asymmetric equals condition */ return val.equalsIgnoreCase((String) x); else return false; } @Override public int hashCode() { return val.toUpperCase().hashCode(); } } 

तब आप इसे अपने परीक्षण करने के लिए उपयोग कर सकते हैं। उदाहरण "पुस्तिका" परीक्षण का मामला:

 public class Test { public static void main(String[] args) { ArrayList<Object> a = new ArrayList<Object>(); a.add("test"); System.out.println(a.contains(new InsensitiveStringComparable("TEST"))); System.out.println(a.contains(new InsensitiveStringComparable("tEsT"))); System.out.println(a.contains(new InsensitiveStringComparable("different"))); } } 

आप IterableUtils का उपयोग कर सकते हैं और कलेक्शन 4 (एपाचे) से मान्य कर सकते हैं।

 List<String> pformats= Arrays.asList("Test","tEst2","tEsT3","TST4"); Predicate<String> predicate = (s) -> StringUtils.equalsIgnoreCase(s, "TEST"); if(IterableUtils.matchesAny(pformats, predicate)) //it is true // do stuff } 

org.apache.commons.collections4.IterableUtils.html

यह विधि इस आधार पर है कि आपके ArrayList रिटर्न में संग्रहीत ऑब्जेक्ट के equals विधि क्या है। तो हां, यह संभव है यदि आप ऐसे ऑब्जेक्ट का उपयोग करते हैं जहां equals केस का उपयोग असंवेदनशील तुलना करता है

तो आप उदाहरण के लिए इस तरह की एक क्लास का उपयोग कर सकते हैं (कोड में कुछ टाइपो भी हो सकते हैं)

 public class CaseInsensitiveString{ private final String contents; public CaseInsensitiveString( String contents){ this.contents = contents; } public boolean equals( Object o ){ return o != null && o.getClass() == getClass() && o.contents.equalsIgnoreCase( contents); } public int hashCode(){ return o.toUpperCase().hashCode(); } } 

एक और समाधान:

 public class IgnorecaseList extends ArrayList<String>{ @Override public boolean contains(Object o) { return indexOf(o) >= 0; } @Override public int indexOf(Object o) { if(o instanceof String){ for (int i = 0; i < this.size(); i++) { if(((String)o).equalsIgnoreCase(get(i))){ return i; } } } return -1; } } 

contains() विधि indexOf का उपयोग करता है … इस sollution में आप यह भी पता कर सकते हैं कि स्थिति कहां है list.add("a") -> list.indexOf("A") == 0 या list.indexOf("a") == 0 ..

आपको सूची के बजाए एक सेट का उपयोग करने पर विचार करना चाहिए।

अतिरिक्त फ़ंक्शन के लिए कोई ज़रूरत नहीं है, वांछित परिणाम तुलनात्मक स्ट्रिंग्स को या तो अपरकेस या लोअरकेस में करके हासिल किया जा सकता है

(मुझे पता है कि यह टिप्पणियों में सुझाव दिया गया है, लेकिन एक उत्तर के रूप में अच्छी तरह से प्रदान नहीं किया गया है)

पूर्व: जेटीईस्टफ़िल्ड से दिए गए इनपुट के आधार पर जेएलआईएस की सामग्री को फ़िल्टर करते हुए मामले को अनदेखा करता है:

 private ArrayList<String> getFilteredUsers(String filter, ArrayList<User> users) { ArrayList<String> filterUsers = new ArrayList<>(); users.stream().filter((user) -> (user.getUsername().toUpperCase().contains(filter.toUpperCase()))).forEach((user)-> { filterUsers.add(user.getUsername()); }); this.userList.setListData(filterUsers.toArray()); return filterUsers; /** * I see the redundancy in returning the object... so even though, * it is passed by reference you could return type void; but because * it's being passed by reference, it's a relatively inexpensive * operation, so providing convenient access with redundancy is just a * courtesy, much like putting the seat back down. Then, the next * developer with the unlucky assignment of using your code doesn't * get the proverbially dreaded "wet" seat. */ } 

जावा 8 के लिए

list.stream ()। किसी भी मैच (एस -> s.equalsIgnoreCase (yourString))

<Java8 के लिए

  • जैसा कि हारून जे लैंग ने सुझाव दिया है
  • या यदि आप अपनी सूची (सभी ऊपरी / सभी निचले) के मामले जानते हैं तो खोज स्ट्रिंग को तुलना करने से पहले उचित केस में परिवर्तित करें

यह आपके सूची आइटम को लोअरकेस में रूपांतरित करने का सर्वोत्तम तरीका है। कनवर्ट करने के बाद आप विधि विधि का उपयोग करेंगे। पसंद

 List<String> name_list = new ArrayList<>(); name_list.add("A"); name_list.add("B"); 

उपरोक्त name_list सूची का उपयोग करके लोअरकेस सूची बनाएं

 List<String> name_lowercase_list = new ArrayList<>(); for(int i =0 ; i<name_list.size(); i++){ name_lowercase_list.add(name_list.get(i).toLowerCase().toString()); } for(int i =0 ; i<name_list.size(); i++){ String lower_case_name = name_list.get(i).toLowerCase().toString(); if(name_list.get(i).contains(your compare item) || name_lowercase_list.get(i).contains(your compare item) ){ //this will return true } } 

मेरे मामले में, जैसा कि ArrayList में मेरे सारे स्ट्रिंग डाउनकेस में हैं, मैं स्ट्रिंग को निष्पादित करता हूं। toLowerCase () विधि में () पैरामीटर शामिल है इस कदर:

 If (yourArrayList.contains (parameterInput.toLowerCase()) { // your code here } 

जैसा कि आप देख सकते हैं, आप ओपोजिट कर सकते हैं, यदि आपके ऑररीलिस्ट में ऊपरी सीज़ स्ट्रिंग है:

 If (yourArrayList.contains (parameterInput.toUpperCase ()) { // your code here } 

इस दृष्टिकोण का उपयोग करके, आपको कुछ भी ओवरराइड करने की आवश्यकता नहीं है। अपवाद तब होता है जब आपकी सरणी सूची में ऊपरी और निचले मामलों का मिश्रण होता है।

यदि आप एक नया फ़ंक्शन नहीं बनाना चाहते हैं, तो आप इस विधि को आज़मा सकते हैं:

 List<String> myList = new ArrayList<String>(); //The list you're checking String wordToFind = "Test"; //or scan.nextLine() or whatever you're checking //If your list has mix of uppercase and lowercase letters letters create a copy... List<String> copyList = new ArrayList<String>(); for(String copyWord : myList){ copyList.add(copyWord.toLowerCase()); } for(String myWord : copyList){ if(copyList.contains(wordToFind.toLowerCase()){ //do something } } 

मैं इसे ऐसा करना चाहूंगा:

 public boolean isStringInList(final List<String> myList, final String stringToFind) { return myList.stream().anyMatch(s -> s.equalsIgnoreCase(stringToFind)); } 

CompareToIgnoreCase का उपयोग करके, http://docs.oracle.com/javase/1.3/docs/api/java/lang/String.html#compareToIgnoreCase%28java.lang.String%29 आप जो चाहते हैं, वह करने में सक्षम होना चाहिए!