घटते क्रम में ArrayList <Long> को कैसे छाँटा जाए?

Question

ArrayList<Long>जावा को घटते क्रम में कैसे छाँटा जाए?

Answer 1

यहाँ आपके लिए एक तरीका है list:

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

या आप Comparatorउल्टे कदम को सुलझाने और खत्म करने के लिए खुद को लागू कर सकते हैं :

list.sort((o1, o2) -> o2.compareTo(o1));

या इससे भी अधिक बस का उपयोग करें Collections.reverseOrder()क्योंकि आप केवल उलट रहे हैं:

list.sort(Collections.reverseOrder());

Comments

l1 > l2 ? -1 : l1 == l2 ? 0 : 1यह कोड हास्यास्पद है। o1.compareTo(o2)तब का उपयोग करें ।

— इललैक्स

@ilya: ओह, हाँ, अच्छा बिंदु है, हालांकि यह होने की जरूरत है o2.compareTo(o1)यहाँ :)

— WhiteFang34

list.sort (Collections.reverseOrder ());

— ट्यूनिक्स

अंगूठे के लिएlist.sort((o1, o2) -> o2.compareTo(o1))

— अखाड़ा

Answer 2

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

Comments

केवल उस चर घोषणा पर एक जेनेरिक तर्क के साथ।

— टॉम हॉकिन -

Answer 3

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

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

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

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

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

Answer 4

जावा 8

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

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

लैम्ब्डा भाव यहाँ रॉक !!!

मामले में आप की तुलना के लिए एक से अधिक पंक्ति तर्क की जरूरत एक और ख आप इसे इस प्रकार लिख सकते

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

Comments

मुझे लगता है कि अगर हम इसे b.compareTo (a) में बदलते हैं, तो हमें संग्रह को उलटने की आवश्यकता नहीं होगी।

— ज़वहुत १

@zawhtut, पूरी तरह से सच! सिर्फ उल्लेख उल्टा () ताकि आप विकल्पों को जान सकें, चुनाव आपका है

— azerafati

क्या आपको लॉन्ग को लॉन्ग में बदलना है?

— BluE

Answer 5

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

Answer 6

लामाओं के लिए जहाँ आपका लंबा मूल्य एक ऐसी वस्तु है जहाँ मैं उपयोग करने की सलाह देता हूँ:

.sorted((o1, o2) -> Long.compare(o1.getLong(), o2.getLong()))

या इससे भी बेहतर:

.sorted(Comparator.comparingLong(MyObject::getLong))

Answer 7

क्रमबद्ध करें, फिर रिवर्स।

Answer 8

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

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

Answer 9

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

Answer 10

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

      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);

        }
    });

Answer 11

तुम भी 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()+" ");
    }
}

Comments

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

Answer 12

इसलिए, कुछ ऐसा है जिसे मैं लाना चाहता हूं जो मुझे लगता है कि महत्वपूर्ण है और मुझे लगता है कि आपको विचार करना चाहिए। रनटाइम और मेमोरी। कहते हैं कि आपके पास एक सूची है और आप इसे क्रमबद्ध करना चाहते हैं, अच्छी तरह से आप कर सकते हैं, एक तरह से बनाया गया है या आप अपना खुद का विकास कर सकते हैं। फिर आप कहते हैं, सूची को उलटना चाहते हैं। वह उत्तर है जो ऊपर सूचीबद्ध है।

यदि आप उस सूची को बना रहे हैं, तो इसे स्टोर करने के लिए एक अलग डेटास्ट्रक्चर का उपयोग करना अच्छा हो सकता है और फिर इसे केवल एक सरणी में डंप करें।

हीप ऐसा करते हैं। आप डेटा में फ़िल्टर करते हैं, और यह सब कुछ संभाल लेगा, फिर आप ऑब्जेक्ट से सब कुछ पॉप कर सकते हैं और इसे सॉर्ट किया जाएगा।

एक अन्य विकल्प यह समझना होगा कि नक्शे कैसे काम करते हैं। बहुत बार, कुछ चीजों के रूप में एक मानचित्र या हैशपैप को कहा जाता है, इसके पीछे एक अंतर्निहित अवधारणा होती है।

उदाहरण के लिए .... आप कुंजी-मूल्य वाले जोड़े के एक समूह में फ़ीड करते हैं जहां कुंजी लंबी होती है, और जब आप सभी तत्वों को जोड़ते हैं, तो आप ऐसा कर सकते हैं: .keysऔर यह आपके लिए एक सॉर्ट की गई सूची में स्वचालित रूप से वापस आ जाएगा।

यह इस बात पर निर्भर करता है कि आप डेटा को कैसे संसाधित करते हैं, इससे पहले कि मैं समझता हूं कि आपको अपनी छंटनी और बाद के बदलावों के साथ कैसे जारी रखना चाहिए

Answer 13

तुलना करने वाले की तुलना विधि का उपयोग वस्तुओं की तुलना करने के लिए किया जा सकता है और फिर reversed()आदेश को उलटने के लिए विधि को लागू किया जा सकता है -

list.stream().sorted(Comparator.comparing(Employee::getName).reversed()).collect(toList());