[Java] ArrayList को कैसे क्रमबद्ध करें?


Answers

Java.util.Collections वर्ग, यानी उपयोग विधि का प्रयोग करें

Collections.sort(list)

वास्तव में, यदि आप कस्टम ऑब्जेक्ट को सॉर्ट करना चाहते हैं तो आप इसका उपयोग कर सकते हैं

Collections.sort(List<T> list, Comparator<? super T> c) 

संग्रह एपीआई देखें

Question

मेरे पास जावा में युगल की एक सूची है और मैं ArrayList को अवरोही क्रम में क्रमबद्ध करना चाहता हूं

इनपुट ArrayList की तरह है-

  List<Double> testList=new ArrayList();

    testList.add(0.5);
    testList.add(0.2);
    testList.add(0.9);
    testList.add(0.1);
    testList.add(0.1);
    testList.add(0.1);
    testList.add(0.54);
    testList.add(0.71);
    testList.add(0.71);
    testList.add(0.71);
    testList.add(0.92);
    testList.add(0.12);
    testList.add(0.65);
    testList.add(0.34);
    testList.add(0.62);

बाहर रखा जाना इस तरह होना चाहिए

0.92
0.9
0.71
0.71
0.71
0.65
0.62
0.54
0.5
0.34
0.2
0.12
0.1
0.1
0.1  



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

              ArrayList<Group> groupList = new ArrayList<>();
              Collections.sort(groupList, Collections.reverseOrder());
              Collections.reverse(groupList);



यदि आप जावा एसई 8 का उपयोग कर रहे हैं, तो यह मदद की जा सकती है।

//create a comparator object using a Lambda expression
Comparator<Double> compareDouble = (d1, d2) -> d1.compareTo(d2);

//Sort the Collection in this case 'testList' in reverse order
Collections.sort(testList, Collections.reverseOrder(compareDouble));

//print the sorted list using method reference only applicable in SE 8
testList.forEach(System.out::println);



जावा 8 में अब यह बहुत आसान है।

List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four");
List<String> alphaNumbersUpperCase = alphaNumbers.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]

- इसके विपरीत उपयोग के लिए

.sorted (Comparator.reverseOrder ())




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

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

एक और वर्बोज संस्करण:

// Implement a reverse-order Comparator by lambda function
Comparator<Double> comp = (Double a, Double b) -> {
    return b.compareTo(a);
};

Collections.sort(testList, comp);

लैम्ब्डा का उपयोग संभव है क्योंकि तुलनात्मक इंटरफ़ेस में लागू करने के लिए केवल एक ही विधि है, इसलिए वीएम अनुमान लगा सकता है कि कौन सी विधि कार्यान्वित कर रही है। चूंकि परम के प्रकारों का अनुमान लगाया जा सकता है, इसलिए उन्हें (Double a, Double b) बजाय (यानी (a, b) कहा जाना चाहिए। और चूंकि लैम्ब्डा शरीर में केवल एक पंक्ति है, और विधि है एक मूल्य वापस करने की उम्मीद है, return अनुमानित है और ब्रेसिज़ आवश्यक नहीं हैं।




बस लूप या डिफ़ॉल्ट सॉर्ट () फ़ंक्शन का उपयोग करें।

for(int n = 0; n<= arrList[i]; n++){
   i



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

MutableDoubleList doubleList =
    DoubleLists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis().reverseThis();
doubleList.each(System.out::println);

यदि आप एक List<Double> , तो निम्नलिखित काम करेगा।

List<Double> objectList =
    Lists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis(Collections.reverseOrder());
objectList.forEach(System.out::println);

यदि आप इस प्रकार को ArrayList<Double> रूप में रखना चाहते हैं, तो आप निम्नानुसार ArrayListIterate उपयोगिता वर्ग का उपयोग करके सूची को प्रारंभ और क्रमबद्ध कर सकते हैं:

ArrayList<Double> arrayList =
    ArrayListIterate.sortThis(
            new ArrayList<>(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);

नोट: मैं ग्रहण संग्रह के लिए एक कमिटर हूं।




Collections.sort आपको एक Comparator का एक उदाहरण पास करने की अनुमति देता है जो सॉर्टिंग तर्क को परिभाषित करता है। तो प्राकृतिक क्रम में सूची को क्रमबद्ध करने और फिर इसे उलट करने के बजाय, कोई भी Collections.reverseOrder() क्रम में क्रमबद्ध करने के क्रम में क्रमबद्ध करने के लिए Collections.reverseOrder() को पारित कर सकता है:

// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());

जैसा कि @ मार्को 13 द्वारा उल्लिखित किया गया है, रिवर्स ऑर्डर तुलनित्र का उपयोग करके अधिक मूर्खतापूर्ण (और संभवतः अधिक कुशल) होने के अलावा, यह सुनिश्चित करता है कि क्रम स्थिर है (जिसका अर्थ यह है कि जब वे तुलनित्र के बराबर होते हैं तो तत्वों का क्रम नहीं बदला जाएगा, जबकि उलट करने से ऑर्डर बदल जाएगा)




Java8 के साथ सूची इंटरफ़ेस पर एक डिफ़ॉल्ट सॉर्ट विधि है जो आपको एक तुलनात्मक प्रदान करने पर संग्रह को सॉर्ट करने की अनुमति देगी। आप आसानी से प्रश्न में उदाहरण को सॉर्ट कर सकते हैं:

testList.sort((a, b) -> Double.compare(b, a));

नोट: लैम्बडा में तर्क अलग-अलग होने पर यह सुनिश्चित करने के लिए Double.compare में पारित होने पर स्वैप किया जाता है






Links