सवाल ArrayList जावा में घटते क्रम में कैसे सॉर्ट करें?


घटते क्रम में जावा में ArrayList को कैसे सॉर्ट करें?


86
2018-05-05 08:36


मूल




जवाब:


यहां आपके लिए एक रास्ता है list:

Collections.sort(list);
Collections.reverse(list);

या आप अपना खुद का कार्यान्वयन कर सकते हैं Comparator रिवर्स चरण को क्रमबद्ध करने और खत्म करने के लिए:

Collections.sort(list, new Comparator<Long>() {
    public int compare(Long o1, Long o2) {
        return o2.compareTo(o1);
    }
});

या यहां तक ​​कि अधिक आसानी से उपयोग करें Collections.reverseOrder() चूंकि आप केवल उलटा कर रहे हैं:

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

215
2018-05-05 08:38



l1 > l2 ? -1 : l1 == l2 ? 0 : 1 यह कोड हास्यास्पद है। उपयोग o1.compareTo(o2) फिर। - ilalex
@ilya: ओह हाँ, अच्छा बिंदु, हालांकि यह होना चाहिए o2.compareTo(o1) यहाँ :) - WhiteFang34
ऐसा लगता है कि यह काम कर रहा है और एक आसान समाधान है। - Rohith K
list.sort (Collections.reverseOrder ()); - tunix


Comparator<Long> comparator = Collections.reverseOrder();
Collections.sort(arrayList, comparator);

25
2018-05-05 08:39



केवल उस परिवर्तनीय घोषणा पर जेनेरिक तर्क के साथ। - Tom Hawtin - tackline


आप नीचे दिए गए कोड का उपयोग कर सकते हैं;

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

या यदि आप कस्टम तुलनित्र का उपयोग करने जा रहे हैं तो आप इसका उपयोग कर सकते हैं जैसा कि नीचे दिया गया है

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

जहां कस्टमकंपेटर एक तुलनित्र वर्ग है जो सूची में मौजूद वस्तु की तुलना करता है।


17
2018-06-26 08:15





जावा 8

जावा 8 में यह अच्छा करना बहुत मजेदार और आसान है

Collections.sort(variants,(a,b)->a.compareTo(b));
Collections.reverse(variants);

Lambda अभिव्यक्ति यहाँ रॉक !!!

यदि आपको तुलना करने के लिए एक से अधिक लाइन तर्क की आवश्यकता होती है  तथा  आप इसे इस तरह लिख सकते हैं

Collections.sort(variants,(a,b)->{
    int result = a.compareTo(b);
    return result;
});

9
2018-04-18 12:34



मुझे लगता है कि अगर हम इसे b.compare में बदलते हैं (ए), तो हमें संग्रह को उलट करने की आवश्यकता नहीं होगी। - zawhtut
@zawhtut, पूरी तरह से सच है! बस उल्टा उल्टा () ताकि आप विकल्पों को जान सकें, पसंद तुम्हारा है - azerafati


सामान्य रूप से क्रमबद्ध करें और उपयोग करें Collections.reverse();


7
2018-05-05 08:38





क्रमबद्ध करें, फिर उल्टा करें।


2
2018-05-05 08:38





नीचे अपने स्वयं के तुलनात्मक को लागू करने के लिए एक और सामान्य दृष्टिकोण

Collections.sort(lst,new Comparator<Long>(){
                public int compare(Long o1, Long o2) {
                    return o2.compareTo(o1);
                }
            });

2
2018-05-05 08:51





निम्नलिखित दृष्टिकोण सूची को अवरोही क्रम में क्रमबद्ध करेगा और 'शून्य'मान, बस अगर आपके पास कोई शून्य मूल्य है तो Collections.sort () फेंक देगा शून्य सूचक अपवाद

      Collections.sort(list, new Comparator<Long>() {
          public int compare(Long o1, Long o2) {
                  return o1==null?Integer.MAX_VALUE:o2==null?Integer.MIN_VALUE:o2.compareTo(o1);

        }
    });

2
2018-05-15 13:13





का उपयोग करके Collections.sort() एक तुलनित्र के साथ जो घटते क्रम प्रदान करता है। के लिए जावाडोक देखें Collections.sort


1
2018-05-05 08:39





आप एक सॉर्ट भी कर सकते हैं ArrayList के साथ TreeSet के बजाय एक comparator। एक पूर्णांक सरणी के लिए पहले मेरे पास एक प्रश्न से एक उदाहरण दिया गया है। मैं "नंबर" का उपयोग प्लेसहोल्डर नाम के रूप में कर रहा हूं ArrayList


     import.java.util.*;
        class MyClass{
        public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        ArrayList<Integer> numbers = new ArrayList<Integer>(); 

        TreeSet<Integer> ts = new TreeSet<Integer>(numbers);
        numbers = new ArrayList<Integer>(ts);
        System.out.println("\nThe numbers in ascending order are:");
        for(int i=0; i<numbers.size(); i++)
        System.out.print(numbers.get(i).intValue()+" ");
        System.out.println("\nThe numbers in descending order are:");
        for(int i=numbers.size()-1; i>=0; i--)
        System.out.print(numbers.get(i).intValue()+" ");
    }
}

0
2017-08-10 03:30



परंतु TreeSet डुप्लिकेट मानों को स्टोर नहीं करता है।