दिलचस्प पोस्ट
स्विफ्ट में NS_OPTIONS- शैली बिटमैस्क एन्यूमरेशन कैसे बनाएं? php – एक गूंज स्ट्रिंग में एक चर डालें ऑब्जेक्ट की एक सरणी को सॉर्ट करने के लिए सरल फ़ंक्शन HttpURL कनेक्शन के लिए शीर्षलेख जोड़ना मैं पायथन में नेस्टेड सूची में केवल एक ही तत्व क्यों नहीं बदल सकता छोटी देव टीम के लिए गिट की शाखा की रणनीति Google Play सेवाओं के साथ एंड्रॉइड स्टूडियो अपने स्थानीय और जिथब रिपॉजिटरी में एक फ़ाइल की अलग-अलग सामग्री कैसे रखनी है? VB.net JSON Deserialize ऑब्जेक्ट के लिए XML स्ट्रिंग को कन्वर्ट करें सी मल्टी-लाइन मैक्रो: करो / जबकि (0) बनाम स्कोप ब्लॉक किसी एप्लिकेशन को स्थापना रद्द करने से कैसे रोकें? जावास्क्रिप्ट: स्ट्रिंग क्लास के लिए विधि जोड़ें ग्रहण नहीं चला सकते; JVM समाप्त निकास कोड = 13 यह देखने के लिए एक स्ट्रिंग जांचें कि क्या सभी वर्ण हेक्साडेसिमल मान हैं

एक कस्टम तुलनित्र का उपयोग करते हुए इनट की एक सरणी कैसे सॉर्ट करनी है?

मुझे एक कस्टम तुलनित्र का उपयोग करते हुए इनट्स की एक सरणी को सॉर्ट करने की आवश्यकता है, लेकिन जावा की लाइब्रेरी तुलनित्रों के साथ ints के लिए एक प्रकार का फ़ंक्शन प्रदान नहीं करती है (तुलनित्र केवल ऑब्जेक्ट के साथ इस्तेमाल किया जा सकता है) ऐसा करने के लिए कोई आसान तरीका है?

वेब के समाधान से एकत्रित समाधान "एक कस्टम तुलनित्र का उपयोग करते हुए इनट की एक सरणी कैसे सॉर्ट करनी है?"

यदि आप अपने इनपुट ऐरे के प्रकार को बदल नहीं सकते हैं तो निम्न कार्य करेगा:

 final int[] data = new int[] { 5, 4, 2, 1, 3 }; final Integer[] sorted = ArrayUtils.toObject(data); Arrays.sort(sorted, new Comparator<Integer>() { public int compare(Integer o1, Integer o2) { // Intentional: Reverse order for this demo return o2.compareTo(o1); } }); System.arraycopy(ArrayUtils.toPrimitive(sorted), 0, data, 0, sorted.length); 

यह ArrayUtils को कॉमन्स-लैंग प्रोजेक्ट से आसानी से int[] और Integer[] के बीच में परिवर्तित करने के लिए उपयोग करता है, सरणी की प्रतिलिपि बनाता है, सॉर्ट करता है, और फिर सॉर्ट किए गए डेटा को मूल पर प्रतिलिपि बनाता है

धाराओं (जावा 8) का उपयोग करने के बारे में कैसे?

 int[] ia = {99, 11, 7, 21, 4, 2}; ia = Arrays.stream(ia). boxed(). sorted((a, b) -> b.compareTo(a)). // sort descending mapToInt(i -> i). toArray(); 

या इन-प्लेस:

 int[] ia = {99, 11, 7, 21, 4, 2}; System.arraycopy( Arrays.stream(ia). boxed(). sorted((a, b) -> b.compareTo(a)). // sort descending mapToInt(i -> i). toArray(), 0, ia, 0, ia.length ); 

एक public static <T> void Arrays.sort(T[] a, Comparator<? super T> c) में अपनी इंट सरणी को बदलने और फिर public static <T> void Arrays.sort(T[] a, Comparator<? super T> c) (पहला चरण केवल आवश्यक है क्योंकि मुझे डर है कि autoboxing पर काम कर सकते हैं सरणियों)।

यदि आप सरणी की प्रतिलिपि नहीं करना चाहते हैं (कहें तो यह बहुत बड़ा है), तो आप एक आवरण सूची बनाना चाह सकते हैं जो एक तरह से उपयोग की जा सकती है:

 final int[] elements = {1, 2, 3, 4}; List<Integer> wrapper = new AbstractList<Integer>() { @Override public Integer get(int index) { return elements[index]; } @Override public int size() { return elements.length; } @Override public Integer set(int index, Integer element) { int v = elements[index]; elements[index] = element; return v; } }; 

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

यहां काम करने के लिए एक सहायक विधि है I

सबसे पहले आपको एक नया तुलनात्मक इंटरफ़ेस की आवश्यकता होगी, क्योंकि कंपैटर प्राथमिकताओं का समर्थन नहीं करता है:

 public interface IntComparator{ public int compare(int a, int b); } 

(आप निश्चित रूप से इसे ऑटोबॉक्सिंग / अनबॉक्सिंग के साथ कर सकते हैं लेकिन मैं वहां नहीं जाऊंगा, यह बदसूरत है)

उसके बाद, इस तुलनित्र का उपयोग करके एक पूर्णांक सरणी सॉर्ट करने के लिए यहां एक सहायक विधि है:

 public static void sort(final int[] data, final IntComparator comparator){ for(int i = 0; i < data.length + 0; i++){ for(int j = i; j > 0 && comparator.compare(data[j - 1], data[j]) > 0; j--){ final int b = j - 1; final int t = data[j]; data[j] = data[b]; data[b] = t; } } } 

और यहाँ कुछ क्लाइंट कोड है एक बेवकूफ तुलनित्र जो सभी नंबरों को संक्रमित करता है जो केवल 9 अंकों के सामने (आकार के अनुसार क्रमबद्ध होता है) और फिर बाकी (जो भी अच्छा है) के लिए होता है:

 final int[] data = { 4343, 544, 433, 99, 44934343, 9999, 32, 999, 9, 292, 65 }; sort(data, new IntComparator(){ @Override public int compare(final int a, final int b){ final boolean onlyNinesA = this.onlyNines(a); final boolean onlyNinesB = this.onlyNines(b); if(onlyNinesA && !onlyNinesB){ return -1; } if(onlyNinesB && !onlyNinesA){ return 1; } return Integer.valueOf(a).compareTo(Integer.valueOf(b)); } private boolean onlyNines(final int candidate){ final String str = String.valueOf(candidate); boolean nines = true; for(int i = 0; i < str.length(); i++){ if(!(str.charAt(i) == '9')){ nines = false; break; } } return nines; } }); System.out.println(Arrays.toString(data)); 

आउटपुट:

 [9, 99, 999, 9999, 32, 65, 292, 433, 544, 4343, 44934343] 

सॉर्ट कोड Arrays.sort (int []) से लिया गया था, और मैंने केवल उस संस्करण का उपयोग किया है जो छोटे एरे के लिए अनुकूलित है। एक वास्तविक कार्यान्वयन के लिए आप शायद आंतरिक विधि sort1(int[], offset, length) के स्रोत कोड को एरेज़ क्लास में देखना चाहते हैं।

मैंने तुलनित्र को आदिम प्रकार के साथ उपयोग करने के लिए अधिकतम प्रयास किया अंत में मैंने निष्कर्ष निकाला कि तुलनित्र को धोखा देने का कोई रास्ता नहीं है। यह मेरा क्रियान्वयन है

 public class ArrSortComptr { public static void main(String[] args) { int[] array = { 3, 2, 1, 5, 8, 6 }; int[] sortedArr=SortPrimitiveInt(new intComp(),array); System.out.println("InPut "+ Arrays.toString(array)); System.out.println("OutPut "+ Arrays.toString(sortedArr)); } static int[] SortPrimitiveInt(Comparator<Integer> com,int ... arr) { Integer[] objInt=intToObject(arr); Arrays.sort(objInt,com); return intObjToPrimitive(objInt); } static Integer[] intToObject(int ... arr) { Integer[] a=new Integer[arr.length]; int cnt=0; for(int val:arr) a[cnt++]=new Integer(val); return a; } static int[] intObjToPrimitive(Integer ... arr) { int[] a=new int[arr.length]; int cnt=0; for(Integer val:arr) if(val!=null) a[cnt++]=val.intValue(); return a; } } class intComp implements Comparator<Integer> { @Override //your comparator implementation. public int compare(Integer o1, Integer o2) { // TODO Auto-generated method stub return o1.compareTo(o2); } } 

@ रमन: मैं यह नहीं कह सकता कि यह एक अच्छा उदाहरण है, लेकिन जबसे आपने यह पूछा तो मेरे दिमाग में क्या आया। मान लीजिए एक सरणी में आप सॉर्ट करना चाहते हैं, बस उनके पूर्ण मूल्य के आधार पर।

 Integer d1=Math.abs(o1); Integer d2=Math.abs(o2); return d1.compareTo(d2); 

एक और उदाहरण ऐसा हो सकता है कि आप 100 से अधिक संख्याओं को सॉर्ट करना चाहते हैं। यह वास्तव में स्थिति पर निर्भर करता है। मैं किसी भी अधिक परिस्थितियों के बारे में सोच नहीं सकता। शायद एलेक्जेंड्रू अधिक उदाहरण दे सकता है क्योंकि वह कहते हैं कि वह चाहते हैं कि वह एक सरणी के लिए तुलनित्र ।

आप फास्टुलेट लाइब्रेरी से IntArrays.quickSort IntArrays.quickSort(array, comparator) उपयोग कर सकते हैं।