दिलचस्प पोस्ट
हाइबरनेट बनाम जेपीए बनाम जेडीओ – पेशेवरों और प्रत्येक के विचार? JSON को रूबी हैश ऑब्जेक्ट कैसे परिवर्तित करें? एक txt फ़ाइल प्रोग्राम से शब्द गणना XmlSerializer – प्रकार दर्शाती हुई एक त्रुटि थी लूप के लिए पायथन लूप काउंटर एंड्रॉइड वेबव्यू, एसेट फ़ोल्डर में जावास्क्रिप्ट फ़ाइल को लोड करना सक्रिय टैब परिवर्तन के लिए 3 jquery ईवेंट बूटस्ट्रैप Django-tastypie: POST में फ़ाइल अपलोड पर कोई भी उदाहरण? File.ReadLines () और File.ReadAllLines () में क्या अंतर है? एचटीटीपी समर्थन के साथ एचटीटीप्लेस्टनर एंड्रॉइड पर एसवीजी समर्थन गतिशील रूप से भरी हुई जावास्क्रिप्ट के अंदर फायरबग ब्रेक बनाना PHPMailer – SSL3_GET_SERVER_CERTIFICATE: प्रमाणपत्र सत्यापित करना विफल हुआ वास्तविक समय subprocess.Popen stdout और PIPE के माध्यम से सिंगलटन के लिए वैकल्पिक क्या है

मेरा सॉर्टिंग लूप एक तत्व को जोड़ने के लिए क्यों लगता है जहां यह नहीं होना चाहिए?

मैं compareTo() का उपयोग करके compareTo() की एक सरणी को सॉर्ट करने की कोशिश कर रहा हूं। यह मेरा कोड है:

 static String Array[] = {" Hello ", " This ", "is ", "Sorting ", "Example"}; String temp; public static void main(String[] args) { for (int j=0; j<Array.length;j++) { for (int i=j+1 ; i<Array.length; i++) { if (Array[i].compareTo(Array[j])<0) { String temp = Array[j]; Array[j] = Array[i]; Array[i] = temp; } } System.out.print(Array[j]); } } 

अब आउटपुट है:

 Hello This Example Sorting is 

मुझे नतीजे मिल रहे हैं, लेकिन मैं जो परिणाम प्राप्त करना चाहता हूं, वह न हो:

 Hello This Example Is Sorting 

स्ट्रिंग एरे को ठीक तरह से सॉर्ट करने के लिए मैं अपने कोड को कैसे समायोजित कर सकता हूँ?

Solutions Collecting From Web of "मेरा सॉर्टिंग लूप एक तत्व को जोड़ने के लिए क्यों लगता है जहां यह नहीं होना चाहिए?"

आपका आउटपुट सही है। शुरुआत में "हेलो" और "यह" के श्वेत पात्रों को निरूपित करें

एक और मुद्दा आपकी पद्धति के साथ है Arrays.sort() विधि का प्रयोग करें:

 String[] strings = { " Hello ", " This ", "Is ", "Sorting ", "Example" }; Arrays.sort(strings); 

आउटपुट:

  Hello This Example Is Sorting 

यहां सरणी का तीसरा तत्व "है" होना चाहिए "है", अन्यथा यह सॉर्टिंग के बाद आखिर में आएगा। चूंकि सॉर्ट विधि आंतरिक रूप से तत्वों को सॉर्ट करने के लिए ASCII मान का उपयोग करती है

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

ऐसा लगता है कि आप एक चयन सॉर्ट एल्गोरिथम को लागू करने की कोशिश कर रहे थे। मैं यहाँ कैसे काम करता है छांटने के विवरण में नहीं जाऊंगा, लेकिन मैंने आपके संदर्भ के लिए कुछ लिंक शामिल किए हैं)

आपका कोड वाक्यविन्यास सही था, लेकिन तार्किक रूप से गलत है आप आंशिक रूप से अपनी स्ट्रिंग्स को केवल प्रत्येक स्ट्रिंग की स्ट्रिंग के साथ तुलना करके वर्गीकृत करते थे जो इसके बाद आए थे । यहां एक सही संस्करण है (मैं यह बताता हूं कि इसके साथ "गलत" क्या था, यह जानने के लिए आपके मूल कोड का अधिक से अधिक रखा गया है):

 static String Array[]={" Hello " , " This " , "is ", "Sorting ", "Example"}; String temp; //Keeps track of the smallest string's index int shortestStringIndex; public static void main(String[] args) { //I reduced the upper bound from Array.length to (Array.length - 1) for(int j=0; j < Array.length - 1;j++) { shortestStringIndex = j; for (int i=j+1 ; i<Array.length; i++) { //We keep track of the index to the smallest string if(Array[i].trim().compareTo(Array[shortestStringIndex].trim())<0) { shortestStringIndex = i; } } //We only swap with the smallest string if(shortestStringIndex != j) { String temp = Array[j]; Array[j] = Array[shortestStringIndex]; Array[shortestStringIndex] = temp; } } } 

आगे की पढाई

इस दृष्टिकोण के साथ समस्या यह है कि इसकी असिम्प्टिक जटिलता ओ (एन ^ 2) है सरलीकृत शब्दों में, यह बहुत धीमा हो जाता है क्योंकि सरणी का आकार बढ़ता है (अनगिनत दृष्टिकोण)। आप डेटा को सॉर्ट करने के बेहतर तरीके के बारे में पढ़ना चाहते हैं, जैसे कि द्रुतोर्ट

इस रेखा के बजाय

 if(Array[i].compareTo(Array[j])<0) 

इस लाइन का उपयोग करें

 if(Array[i].trim().compareTo(Array[j].trim())<0) 

और आप जाने के लिए अच्छा है इसका कारण यह है कि आपका वर्तमान कोड काम नहीं कर रहा है अन्य उपयोगकर्ताओं द्वारा पहले से ही समझाया गया है यह ऊपर प्रतिस्थापन कई में एक वैकल्पिक हल है कि आप आवेदन कर सकते हैं

मुझे पता है यह एक देर से उत्तर है, लेकिन शायद यह किसी की मदद कर सकता है

ट्रिम () फ़ंक्शन का उपयोग करके सफेद स्थान को हटाया जा सकता है। इसके बाद यदि आप केस संवेदनशील तरीके से सरणी को सॉर्ट करना चाहते हैं तो आप इसका उपयोग कर सकते हैं:

 Arrays.sort(yourArray); 

और मामले के लिए असंवेदनशील तरीके से:

 Arrays.sort(yourArray,String.CASE_INSENSITIVE_ORDER); 

उम्मीद है की यह मदद करेगा!

जावा 8 से शुरू होकर, आप parallelSort उपयोग भी कर सकते हैं जो उपयोगी है यदि आपके पास कई तत्व हैं

उदाहरण:

 public static void main(String[] args) { String[] strings = { "x", "a", "c", "b", "y" }; Arrays.parallelSort(strings); System.out.println(Arrays.toString(strings)); // [a, b, c, x, y] } 

यदि आप मामले को अनदेखा करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

 public static void main(String[] args) { String[] strings = { "x", "a", "c", "B", "y" }; Arrays.parallelSort(strings, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } }); System.out.println(Arrays.toString(strings)); // [a, B, c, x, y] } 

अन्यथा B a से पहले होगा।

यदि आप तुलना के दौरान पीछे वाले स्थान की अनदेखी करना चाहते हैं, तो आप trim() उपयोग कर सकते हैं:

 public static void main(String[] args) { String[] strings = { "x", " a", "c ", " b", "y" }; Arrays.parallelSort(strings, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.trim().compareTo(o2.trim()); } }); System.out.println(Arrays.toString(strings)); // [ a, b, c , x, y] } 

देखें :

" Hello " , " This " , "is ", "Sorting ", "Example"

सबसे पहले आप " Hello " और " This " में रिक्त स्थान प्रदान करते हैं, रिक्त स्थान की यूनिकोड में वर्णमाला वर्णों की तुलना में कम मान होता है, इसलिए इसे पहले छपेटा जाता है। (बाकी वर्ण वर्णानुक्रम में क्रमबद्ध थे)।

अब ऊपरी केस अक्षरों में यूनिकोड में लोअर केस लेटर के मुकाबले कम मान होता है, इसलिए "उदाहरण" और "सॉर्टिंग" प्रिंट हो जाता है, फिर आखिरी "is " जो कि सर्वोच्च मूल्य है

यदि तुम प्रयोग करते हो:

 if (Array[i].compareToIgnoreCase(Array[j]) < 0) 

तुम्हे मिल जाएगा:

 Example Hello is Sorting This 

जो मुझे लगता है कि वह आउटपुट है जिसे आप ढूंढ रहे थे।

आरंभ करने के लिए, आपकी समस्या यह है कि आप “ तुलना करें () विधि का उपयोग करते हैं जो मामले संवेदनशील है इसका अर्थ है कि निचले मामले से अलग-अलग कैपिटल अक्षरों को हल किया जाता है। इसका कारण यह है कि यूनिकोड में इसका अनुवाद किया गया है जहां राजधानी अक्षरों को संख्याओं के साथ प्रस्तुत किया गया है जो कम से कम मामले की संख्या से कम है। इस प्रकार आपको 'तुलना करेंइग्नेरसीज ()' का उपयोग करना चाहिए क्योंकि पिछली पोस्ट में उल्लेखित बहुत से

यह मेरा पूर्ण उदाहरण दृष्टिकोण है कि आप इसे कैसे प्रभावी ढंग से कर सकते हैं

तुलनित्र के एक ऑब्जेक्ट को बनाने के बाद आप इसे `sort ()` के इस संस्करण में पास कर सकते हैं, जो java.util.Arrays में परिभाषित है।

 static<T>void sort(T[]array,Comparator<?super T>comp) 

सुपर पर एक करीबी नज़र रखना यह सुनिश्चित करता है कि सरणी जो पारित होती है तुलनित्र के प्रकार के साथ मुकाबला है

इस तरह का जादू हिस्सा यह है कि आप रिवर्स ऑर्डर में आसानी से तारों की सरणी को सॉर्ट कर सकते हैं जिसे आप आसानी से कर सकते हैं:

 return strB.compareToIgnoreCase(strA); 

 import java.util.Comparator; public class IgnoreCaseComp implements Comparator<String> { @Override public int compare(String strA, String strB) { return strA.compareToIgnoreCase(strB); } } 

  import java.util.Arrays; public class IgnoreCaseSort { public static void main(String[] args) { String strs[] = {" Hello ", " This ", "is ", "Sorting ", "Example"}; System.out.print("Initial order: "); for (String s : strs) { System.out.print(s + " "); } System.out.println("\n"); IgnoreCaseComp icc = new IgnoreCaseComp(); Arrays.sort(strs, icc); System.out.print("Case-insesitive sorted order: "); for (String s : strs) { System.out.print(s + " "); } System.out.println("\n"); Arrays.sort(strs); System.out.print("Default, case-sensitive sorted order: "); for (String s : strs) { System.out.print(s + " "); } System.out.println("\n"); } } 

  run: Initial order: Hello This is Sorting Example Case-insesitive sorted order: Hello This Example is Sorting Default, case-sensitive sorted order: Hello This Example Sorting is BUILD SUCCESSFUL (total time: 0 seconds) 

वैकल्पिक विकल्प

विधि की compareToIgnoreCase() , हालांकि यह कई अवसरों के साथ अच्छी तरह से काम करता है (जैसे कि अंग्रेजी में स्ट्रिंग की तुलना करना), यह सभी भाषाओं और स्थानों के साथ अच्छी तरह से काम नहीं करेगा यह स्वतः उपयोग के लिए यह एक अयोग्य विकल्प बनाता है यह सुनिश्चित करने के लिए कि आप जावा compare() टेक्स्ट compare() से compare() उपयोग करना चाहिए।

आप विधि getInstance() को कॉल करके अपने स्थान के लिए कॉलेटर खोज सकते हैं उसके बाद आपको इस कोलेटर की शक्ति संपत्ति सेट करना चाहिए। इसे setStrength() विधि के साथ setStrength() साथ किया जा सकता है। setStrength() पैरामीटर के रूप में इस विकल्प के साथ IgnocaseComp को नीचे लिखा जा सकता है। कोड का यह संस्करण स्थान के स्वतंत्र रूप से एक ही आउटपुट उत्पन्न करेगा

 import java.text.Collator; import java.util.Comparator; //this comparator uses one Collator to determine //the right sort usage with no sensitive type //of the 2 given strings public class IgnoreCaseComp implements Comparator<String> { Collator col; IgnoreCaseComp() { //default locale col = Collator.getInstance(); //this will consider only PRIMARY difference ("a" vs "b") col.setStrength(Collator.PRIMARY); } @Override public int compare(String strA, String strB) { return col.compare(strA, strB); } }