जावा एरे क्रमबद्ध अवरोही?

Question

वहाँ किसी भी तरह से आरोही क्रम में एक सरणी को सॉर्ट करने का तरीका है जैसे कि वे आरोही क्रम में एक प्रकार कैसे है एरेस वर्ग ?

या मुझे आलसी होने से रोकना है और यह स्वयं करना है: [

Comments

पर एक नजर डालें Collections.reverseOrder का प्रयोग

— drorw

Answer 1

आप इसका उपयोग सभी प्रकार की वस्तुओं को क्रमबद्ध करने के लिए कर सकते हैं

sort(T[] a, Comparator<? super T> c) 

Arrays.sort(a, Collections.reverseOrder());

Arrays.sort()अवरोही क्रम में आदिम सरणियों को सॉर्ट करने के लिए सीधे उपयोग नहीं किया जा सकता है। यदि आप Arrays.sort()द्वारा परिभाषित रिवर्स तुलनित्र पास करके विधि को कॉल करने का प्रयास करते हैं Collections.reverseOrder(), तो यह त्रुटि को फेंक देगा

सॉर्ट (इंट [], तुलनित्र) के लिए कोई उपयुक्त विधि नहीं मिली

यह 'एरे ऑफ ऑब्जेक्ट्स' जैसे कि इंटीजर ऐरे के साथ ठीक काम करेगा लेकिन इंटिमेंट एरे जैसे प्राइमरी ऐरे के साथ काम नहीं करेगा।

अवरोही क्रम में एक आदिम सरणी को सॉर्ट करने का एकमात्र तरीका है, पहले आरोही क्रम में सरणी को सॉर्ट करें और फिर सरणी में जगह को उल्टा करें। यह द्वि-आयामी आदिम सरणियों के लिए भी सही है।

Comments

यह

— आदिमों के

अपनी आदतों को उनकी संबंधित वस्तुओं में बदलें। पूर्णांक के लिए पूर्णांक, डबल के लिए डबल, बूलियन के लिए बूलियन, आदि

— इश्माएल

यदि आप अभी भी अपने कस्टम तुलनित्र का उपयोग करना चाहते हैं :Collections.reverseOrder(this)

— सेबस्टियन होजस

Collections.reverseOrder () कोई पैरामीटर नहीं लेता है (जब तक मैं कुछ याद नहीं कर रहा हूं?), इसके बजाय मैंने myComparator.reversed () का उपयोग किया।

— jsaven

Arrays.sort () का उपयोग सीधे अवरोही क्रम में आदिम सरणियों को सॉर्ट करने के लिए नहीं किया जा सकता है। यदि आप Arrays.sort () विधि को कलेक्शन .reverseOrder () द्वारा परिभाषित रिवर्स तुलनित्र पास करके कॉल करने का प्रयास करते हैं, तो यह त्रुटि को फेंक देगा - "सॉर्ट (इंट [], तुलनित्र <ऑब्जेक्ट>" के लिए कोई उपयुक्त विधि नहीं मिली है। इंटेगर सरणी के साथ ठीक काम करते हैं लेकिन एक इंट सरणी के साथ काम नहीं करेंगे। अवरोही क्रम में एक आदिम सरणी को सॉर्ट करने का एकमात्र तरीका है, पहले सरणी को आरोही क्रम में क्रमबद्ध करें और फिर सरणी में जगह को उल्टा करें। यह द्वि-आयामी आदिम सरणियों के लिए भी सही है।

— अकुरीकाओ

Answer 2

एक सूची के लिए

Collections.sort(list, Collections.reverseOrder());

एक सरणी के लिए

Arrays.sort(array, Collections.reverseOrder());

Comments

int [] सरणी = {2,4,3,6,8,7}; Arrays.sort (अरै, कलेक्शंस .reverseOrder ()); मुझे एक त्रुटि दे रहा है! त्रुटि है: "Arrays के प्रकार (int [], तुलनित्र <ऑब्जेक्ट>) के प्रकार में" विधि क्रमांक (int [])

— दीक्षित सिंगला

int कोई वस्तु नहीं है। इसके बजाय Integer [] का उपयोग करने का प्रयास करें।

— ऑर्निथोप्टर

int एक प्राथमिक प्रकार है जबकि Integer नहीं है। यही कारण है कि इंटेगर के पास पार्स, स्ट्रींग आदि जैसी विधियाँ हैं

— ऑर्निथोप्टर

Answer 3

आप इसका उपयोग कर सकते हैं:

    Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder()Comparatorप्रतिलोम प्राकृतिक क्रम का उपयोग करके लौटाता है । आप अपने स्वयं के तुलनित्र का एक उलटा संस्करण प्राप्त कर सकते हैं Collections.reverseOrder(myComparator)।

Comments

ओपी एक सरणी को सॉर्ट करना चाहता है। Collections.sort()एक Listइनपुट पैरामीटर के रूप में लेता है , एक सरणी नहीं।

— पास्कल थिवेंट

Answer 4

एक विकल्प हो सकता है (संख्या के लिए !!!)

1. सरणी को -1 से गुणा करें
2. तरह
3. एक बार फिर -1 से गुणा करें

सचमुच बोली:

array = -Arrays.sort(-array)

Comments

यह विधि वास्तव में रचनात्मक है यदि हम संख्याओं को

— छांट

यह आदिम प्रकारों के लिए बहुत अच्छा जवाब है। तुम अकल्मन्द हो।

— १İ बजे हलील imब्राहिम ओइमैक २ '

सिवाय इसके कि यह करेंगे असफल के लिए Integer.MIN_VALUE(या जो भी आदिम प्रयोग किया जाता है)। sort()तब बेहतर होगा reverse(), लेकिन आपको खुद को उल्टा करना होगा, क्योंकि उन्होंने Arrays.reverse()कार्यान्वयन नहीं किया था ।

— एंड्रियास

@ हलील इब्राहिम ओमेक: -रे सिंटैक्स मेरे लिए काम नहीं करता है: "बुरा ऑपरेटर प्रकार int [] के लिए अपर संचालक '-'"

— लाइन

@ आपको सरणी के लिए एकाधिक -1 होना चाहिए। उपरोक्त कोड छद्म कोड है। आप लूप के लिए एक सरणी में कई -1 कर सकते हैं फिर Array.sort () विधि को कॉल कर सकते हैं, अंत में आप फिर से सरणी के लिए कई -1 कर सकते हैं।

— हलील imब्राहिम ओमिक

Answer 5

बिना स्पष्ट तुलनित्र:

Collections.sort(list, Collections.reverseOrder());

स्पष्ट तुलनित्र के साथ:

Collections.sort(list, Collections.reverseOrder(new Comparator()));

Answer 6

जावा 8:

Arrays.sort(list, comparator.reversed());

अद्यतन: reversed()निर्दिष्ट तुलनित्र को उलट देता है। आमतौर पर, तुलनित्र आरोही क्रम का आदेश देते हैं, इसलिए यह अवरोही क्रम को बदल देता है।

Comments

यह वस्तुओं के साथ पूरी तरह से काम करता है लेकिन आदिम के साथ नहीं। प्रकार के आदिम इंट के लिए, आपको एएससी क्रम में सॉर्ट करना चाहिए और फिर उत्तर को उल्टा करना चाहिए।

— रसेल स्के।

Answer 7

सरणी के लिए, जिसमें आदिम के तत्व शामिल हैं यदि org.apache.commons.lang(3)रिवर्स सरणी के निपटान के लिए आसान तरीका है (इसे सॉर्ट करने के बाद) का उपयोग करना है:

ArrayUtils.reverse(array);

Comments

आरोही क्रम में इसे पहले क्यों छाँटा जाए और फिर इस क्रम को वापस लाने के लिए बाहरी पुस्तकालय का उपयोग करें, जब इसे एक चरण में किया जा सकता है?

— बेटलिस्टा

और वह एक कदम है?

— जोसिप मसलक

हां, लेकिन (जैसा कि उन उत्तरों में टिप्पणियों में कहा गया है) जो कि प्राथमिकताओं के लिए काम नहीं करता है जो कि मेरा उत्तर पता है। बेशक मेरा जवाब इष्टतम नहीं है, लेकिन मैंने इसे "आसान" होने के मानदंडों को पूरा करने के लिए पाया, जिस पर मूल लेखक ने जोर दिया - (अर्थात। Arrays.sort(primitives); ArrayUtils.reverse(primitives);

— जोसिफ मसलक

Answer 8

सबसे पहले आपको अपने सरणी का उपयोग करके सॉर्ट करना होगा:

Collections.sort(Myarray);

फिर आपको आरोही से अवरोही क्रम का उपयोग करने की आवश्यकता है:

Collections.reverse(Myarray);

Answer 9

मुझे नहीं पता कि आपका उपयोग मामला क्या था, हालांकि अन्य उत्तरों के अलावा एक और (आलसी) विकल्प अभी भी आरोही क्रम में सॉर्ट करना है जैसा कि आप इंगित करते हैं लेकिन इसके बजाय रिवर्स ऑर्डर में पुनरावृति करते हैं।

Answer 10

सीधे तौर पर प्राइमेटिव (अर्थात int[] arr = {1, 2, 3};) का उपयोग करके सरणी को उल्टा करना संभव नहीं है Arrays.sort()और Collections.reverseOrder()क्योंकि उन तरीकों Integerको आदिम प्रकार के बजाय संदर्भ प्रकार ( ) की आवश्यकता होती हैint ) के ।

हालाँकि, हम रिवर्स ऑर्डर में सॉर्ट करने के लिए पहले बॉक्स को जावा 8 स्ट्रीम का उपयोग कर सकते हैं:

// an array of ints
int[] arr = {1, 2, 3, 4, 5, 6};

// an array of reverse sorted ints
int[] arrDesc = Arrays.stream(arr).boxed()
    .sorted(Collections.reverseOrder())
    .mapToInt(Integer::intValue)
    .toArray();

System.out.println(Arrays.toString(arrDesc)); // outputs [6, 5, 4, 3, 2, 1]

Answer 11

एक अन्य समाधान है कि आप का इस्तेमाल कर रही रहे हैं तो हम तुलनीय इंटरफ़ेस उन आउटपुट मानों को स्विच कर सकते हैं, जिन्हें आपने अपने में निर्दिष्ट किया था (ऑब्जेक्ट bCompared)।

उदाहरण के लिए :

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= 1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= -1;
    return ret;
}

जहाँ परिमाण हो मेरे कार्यक्रम में डेटाटाइप डबल के साथ एक विशेषता है । यह मेरे परिभाषित वर्ग freq को उल्टा क्रम में इसे परिमाण द्वारा छाँट रहा था। तो क्रम जिसे ठीक करने के लिए, आप मूल्यों से लौटे स्विच <और >। यह आपको निम्नलिखित देता है:

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= -1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= 1;
    return ret;
}

इस तुलना का उपयोग करने के लिए, हम बस कॉल करते हैं Arrays.sort(mFreq)जो आपको क्रमबद्ध सरणी देगाfreq [] mFreq ।

इस समाधान की सुंदरता (मेरी राय में) यह है कि इसका उपयोग उपयोगकर्ता परिभाषित वर्गों को सॉर्ट करने के लिए किया जा सकता है, और इससे भी अधिक उन्हें एक विशिष्ट विशेषता द्वारा सॉर्ट किया जाता है। यदि तुलनात्मक इंटरफ़ेस का कार्यान्वयन आपको कठिन लगता है, तो मैं आपको इस तरह से न सोचने के लिए प्रोत्साहित करूँगा, यह वास्तव में नहीं है। तुलनीय बनायी गयी चीजों को कैसे लागू किया जाए, इस बारे में यह लिंक मेरे लिए बहुत आसान है। उम्मीद करने वाले व्यक्ति इस समाधान का उपयोग कर सकते हैं, और यह कि आपकी खुशी भी होगी मेरी तुलना में ।

Answer 12

array.sort(function(a, b) {return b - a;}); //descending 

या

array.sort(function(a, b) {return a - b;}); //ascending

Comments

कैसे जावा प्रश्न के लिए प्रासंगिक है?

— दिमित्री गिंजबर्ग

Answer 13

मुझे पता है कि यह एक बहुत पुराना धागा है, लेकिन यहाँ Integers और Java 8 का अपडेटेड संस्करण है:

Arrays.sort(array, (o1, o2) -> o2 - o1);

ध्यान दें कि यह सामान्य आरोही क्रम के लिए "ओ 1 - ओ 2" है (या तुलनाकर्ता.कॉमपरिंगआईंट ())।

यह किसी अन्य प्रकार की वस्तुओं के लिए भी काम करता है। कहते हैं:

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());

Comments

यह केवल संदर्भ प्रकार सरणियों के लिए काम करता है, न कि आदिम प्रकारों के सरणियों के लिए।

— किंबौदी

Answer 14

यह मेरे लिए काम किया:

package doublearraysort;

import java.util.Arrays;
import java.util.Collections;

public class Gpa {


    public static void main(String[] args) {
        // initializing unsorted double array
        Double[] dArr = new Double[] {                 
            new Double(3.2),
            new Double(1.2),
            new Double(4.7),
            new Double(3.3),
            new Double(4.6),
           };
        // print all the elements available in list
        for (double number : dArr) {
            System.out.println("GPA = " + number);
        }

        // sorting the array
        Arrays.sort(dArr, Collections.reverseOrder());

        // print all the elements available in list again
        System.out.println("The sorted GPA Scores are:");
        for (double number : dArr) {
            System.out.println("GPA = " + number);
        }
    }
}

आउटपुट:

GPA = 3.2
GPA = 1.2
GPA = 4.7
GPA = 3.3
GPA = 4.6
The sorted GPA Scores are:
GPA = 4.7
GPA = 4.6
GPA = 3.3
GPA = 3.2
GPA = 1.2

Answer 15

public double[] sortArrayAlgorithm(double[] array) { //sort in descending order
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array.length; j++) {
            if (array[i] >= array[j]) {
                double x = array[i];
                array[i] = array[j];
                array[j] = x;
            }
        }
    }
    return array;
}

बस इस विधि का उपयोग अवरोही क्रम में टाइप डबल की एक सरणी को सॉर्ट करने के लिए कर सकते हैं, आप इसका उपयोग किसी भी अन्य प्रकार (जैसे इंट, फ्लोट और आदि) के एरे को सॉर्ट करने के लिए कर सकते हैं, केवल "रिटर्न टाइप", "तर्क प्रकार" और चर "x" प्रकार इसी प्रकार के लिए। यदि आप क्रम को आरोही बनाना चाहते हैं तो आप "> =" से "<=" भी बदल सकते हैं।

Answer 16

आप तुलनाकारक के साथ धारा संचालन ( कलेक्शन.स्ट्रीम () ) का उपयोग कर सकते हैं। ।

उदाहरण के लिए, मान लीजिए कि आपके पास यह संग्रह है:

List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");

आइटमों को उनके "प्राकृतिक" क्रम में मुद्रित करने के लिए आप क्रमबद्ध () विधि का उपयोग कर सकते हैं (या इसे छोड़ दें और समान परिणाम प्राप्त करें):

items.stream()
     .sorted()
     .forEach(item -> System.out.println(item));

या उन्हें (रिवर्स) अवरोही क्रम में मुद्रित करने के लिए, आप इस्तेमाल कर सकते हैं क्रमबद्ध विधि है कि एक तुलनाकारी लेता है और क्रम को उल्टा:

items.stream()
     .sorted(Comparator.reverseOrder())
     .forEach(item -> System.out.println(item));

ध्यान दें कि इस संग्रह के लिए तुलनात्मक रूप से कार्यान्वित किया जाना आवश्यक है (जैसा कि पूर्णांक, स्ट्रिंग, आदि)।

Answer 17

यहां बहुत सारी गड़बड़ चल रही है - लोग गैर-आदिम मूल्यों के लिए समाधान सुझाते हैं, जमीन से कुछ छंटाई करने वाले एल्गो को लागू करने का प्रयास करते हैं, अतिरिक्त पुस्तकालयों से जुड़े समाधान देते हैं, कुछ हैकी दिखाते हैं आदि। मूल प्रश्न का उत्तर 50 है / 50। उन लोगों के लिए जो सिर्फ कॉपी / पेस्ट करना चाहते हैं:

// our initial int[] array containing primitives
int[] arrOfPrimitives = new int[]{1,2,3,4,5,6};

// we have to convert it into array of Objects, using java's boxing
Integer[] arrOfObjects = new Integer[arrOfPrimitives.length];
for (int i = 0; i < arrOfPrimitives.length; i++) 
    arrOfObjects[i] = new Integer(arrOfPrimitives[i]);

// now when we have an array of Objects we can use that nice built-in method
Arrays.sort(arrOfObjects, Collections.reverseOrder());

arrOfObjectsहै {6,5,4,3,2,1}अब। यदि आपके पास ints के अलावा किसी और चीज़ की एक सरणी है - तो इसके बजाय संबंधित ऑब्जेक्ट का उपयोग करें Integer।

Answer 18

ऊपर चर्चा के लिए, यहां अवरोही क्रम में आदिम सरणियों को क्रमबद्ध करना एक आसान उदाहरण है।

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = { 5, 4, 1, 2, 9, 7, 3, 8, 6, 0 };
        Arrays.sort(nums);

        // reverse the array, just like dumping the array!
        // swap(1st, 1st-last) <= 1st: 0, 1st-last: nums.length - 1
        // swap(2nd, 2nd-last) <= 2nd: i++,  2nd-last: j--
        // swap(3rd, 3rd-last) <= 3rd: i++,  3rd-last: j--
        //
        for (int i = 0, j = nums.length - 1, tmp; i < j; i++, j--) {
            tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }

        // dump the array (for Java 4/5/6/7/8/9)
        for (int i = 0; i < nums.length; i++) {
            System.out.println("nums[" + i + "] = " + nums[i]);
        }
    }
}

आउटपुट:

nums[0] = 9
nums[1] = 8
nums[2] = 7
nums[3] = 6
nums[4] = 5
nums[5] = 4
nums[6] = 3
nums[7] = 2
nums[8] = 1
nums[9] = 0

Answer 19

नीचे उतरने के लिए एक अंतर सरणी को सॉर्ट करने के लिए सरल विधि:

private static int[] descendingArray(int[] array) {
    Arrays.sort(array);
    int[] descArray = new int[array.length];
    for(int i=0; i<array.length; i++) {
        descArray[i] = array[(array.length-1)-i];
    }
    return descArray;
}

Answer 20

तुलनित्र के साथ एक और तरीका

import java.util.Arrays;
import java.util.Comparator;
...

Integer[] aInt = {6,2,3,4,1,5,7,8,9,10};
Arrays.sort(aInt, Comparator.reverseOrder()  );