कैसे एक ArrayList सॉर्ट करने के लिए?

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

Answer 1

Collections.sort(testList);
Collections.reverse(testList);

वही करेगा जो आप चाहते हैं। Collectionsहालांकि आयात करने के लिए याद रखें !

यहाँ के लिए प्रलेखन हैCollections ।

Comments

शायद यह ध्यान देने योग्य है कि आप अपने खुद को परिभाषित कर सकते हैं Comparator:)

— Polygnome

@Polygnome ओपी केवल सॉर्टिंग है Double।

— tckmn

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

— बहुपत्नी

@ आयशा हां, पर्दे के पीछे का Collections.sortउपयोग compareToकरती है।

— tckmn

वास्तव में एक का उपयोग करना चाहिए Collections.sort(list, Collections.reverseOrder());। अधिक मुहावरेदार (और संभवतः अधिक कुशल) होने के अलावा, रिवर्स ऑर्डर तुलनित्र का उपयोग करना सुनिश्चित करता है कि सॉर्ट स्थिर है (इसका मतलब है कि तत्वों के क्रम को तब नहीं बदला जाएगा जब वे तुलनित्र के अनुसार समान होते हैं, जबकि पीछे हटने से ऑर्डर बदल जाएगा )।

— मार्को 13

Answer 2

अवरोही:

Collections.sort(mArrayList, new Comparator<CustomData>() {
    @Override
    public int compare(CustomData lhs, CustomData rhs) {
        // -1 - less than, 1 - greater than, 0 - equal, all inversed for descending
        return lhs.customInt > rhs.customInt ? -1 : (lhs.customInt < rhs.customInt) ? 1 : 0;
    }
});

Comments

क्या मैं अगर करना चाहिए CustomData है List<AnotherModel>जो AnotherModelहै idद्वारा प्रकार के और मैं चाहता हूँ id? और मैं सिर्फ CustomData अपनी कक्षा में मॉडल का उपयोग करता हूं।

— डॉ। जकांकी

आप सिर्फ CustomData वर्ग को एक और मॉडल के साथ बदल सकते हैं और इस तरह एक पंक्ति है: lhs.id> rhs.id? -1: .. आदि

— user2808054

तुलनात्मक विवरण बेहतर लिखा जा सकता हैInteger.compare(rhs.customInt, lhs.customInt);

— लॉर्डकिज़

Answer 3

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

Collections.sort(list)

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

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

संग्रह देखें

Answer 4

आपके उदाहरण के लिए, यह जावा 8 में जादू करेगा

List<Double> testList = new ArrayList();
testList.sort(Comparator.naturalOrder());

लेकिन यदि आप जिस वस्तु को छांट रहे हैं, उसके कुछ क्षेत्रों को छाँटना चाहते हैं, तो आप इसे आसानी से कर सकते हैं:

testList.sort(Comparator.comparing(ClassName::getFieldName));

या

 testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());

या

 testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());

स्रोत: https://docs.oracle.com/javase/8/docs/api/java/util/Compar.html

Comments

'तुलना ’-विधि कहाँ स्थित है?

— lippo

आपको आयात करने की आवश्यकता है: स्थैतिक java.util.Comparator.comparing आयात करें;

— krmanish007

यह जावा 1.7 के साथ उपलब्ध है?

— lippo

नहीं, यह स्ट्रीम और

— फ़ंक्शनल

आप सही हैं @AjahnCharles। उन्होंने शून्य-आर्ग निकाल दिया है, इसलिए मैंने अपना उत्तर अब अपडेट कर दिया है।

— krmanish007

Answer 5

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

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

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

Comments

यह अच्छा है, धन्यवाद! यह एक और अधिक कॉम्पैक्ट है: कलेक्शंस.सोर्ट (टेस्टलिस्ट, कम्प्लाइटर .reverseOrder ());

— काविक्स

और भी अधिक कॉम्पैक्ट: testList.sort (तुलनाकर्ता.reverseOrder ());

— jonasespelita

Answer 6

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

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

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

Comments

मेरे लिए यह सबसे अच्छा जवाब है क्योंकि यह वस्तुओं का उपयोग करके छंटाई के लिए भी काम करता है ... उदाहरण locationDetails.sort((locationDetailAsc,locationDetailsDsc) -> Long.compare(locationDetailsDsc.getSnapshot().getQuantity(), locationDetailAsc.getSnapshot().getQuantity()));

— अनस

Answer 7

यदि आपके तत्व शामिल हैं, तो आप Collections.sort(list)सॉर्ट करने के लिए उपयोग कर सकते हैं । अन्यथा मैं आपको उस इंटरफ़ेस को यहां लागू करने की सलाह दूंगा:listlistComparable

public class Circle implements Comparable<Circle> {}

और निश्चित रूप से compareToयहाँ की तरह अपनी खुद की प्राप्ति प्रदान करते हैं:

@Override
    public int compareTo(Circle another) {
        if (this.getD()<another.getD()){
            return -1;
        }else{
            return 1;
        }
    }

और फिर आप फिर से उपयोग कर सकते हैं Colection.sort(list)क्योंकि अब सूची में तुलनीय प्रकार की वस्तुएं हैं और इसे सॉर्ट किया जा सकता है। आदेश compareToविधि पर निर्भर करता है । अधिक विस्तृत जानकारी के लिए इस https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html की जाँच करें ।

Answer 8

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

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

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

Answer 9

//Here is sorted List alphabetically with syncronized

package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

/**
 * @author manoj.kumar
 */
public class SynchronizedArrayList {
    static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
        synchronizedList.add(new Employee("Aditya"));
        synchronizedList.add(new Employee("Siddharth"));
        synchronizedList.add(new Employee("Manoj"));
        Collections.sort(synchronizedList, new Comparator() {
            public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((Employee) synchronizedListOne).name
                        .compareTo(((Employee) synchronizedListTwo).name);
            }
        }); 
    /*for( Employee sd : synchronizedList) {
    log.info("Sorted Synchronized Array List..."+sd.name);
    }*/

        // when iterating over a synchronized list, we need to synchronize access to the synchronized list
        synchronized (synchronizedList) {
            Iterator<Employee> iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
            }
        }

    }
}

class Employee {
    String name;

    Employee(String name) {
        this.name = name;

    }
}

Comments

लगता है कि

— थैस

Answer 10

यहाँ एक छोटी सी धोखाधड़ी है जो विशिष्ट मामलों को कवर करती है:

// sort
list.sort(naturalOrder())

// sort (reversed)
list.sort(reverseOrder())

// sort by field
list.sort(comparing(Type::getField))

// sort by field (reversed)
list.sort(comparing(Type::getField).reversed())

// sort by int field
list.sort(comparingInt(Type::getIntField))

// sort by double field (reversed)
list.sort(comparingDouble(Type::getDoubleField).reversed())

// sort by nullable field (nulls last)
list.sort(comparing(Type::getNullableField, nullsLast(naturalOrder())))

// two-level sort
list.sort(comparing(Type::getField1).thenComparing(Type::getField2))

Answer 11

यदि आप जावा एसई 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);

Comments

वहाँ भी है Collections.reverseOrder()जो अपने क्रियान्वयन करता है, किसी भी तर्क के बिना compareDoubleज़रूरत से ज़्यादा (इसके बारे में प्राकृतिक आदेश के बराबर है Doubleरों)। यहां उत्तर होना चाहिएCollections.sort(testList, Collections.reverseOrder());

— मैट

Answer 12

| * | एक सूची को क्रमबद्ध करना:

import java.util.Collections;

| => सॉर्ट एस्क ऑर्डर:

Collections.sort(NamAryVar);

| => क्रमबद्ध Dsc क्रम:

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

---

| * | सूची के क्रम को उल्टा करें:

Collections.reverse(NamAryVar);

Answer 13

आप इस तरह कर सकते हैं:

List<String> yourList = new ArrayList<String>();
Collections.sort(yourList, Collections.reverseOrder());

संग्रह में एक डिफ़ॉल्ट तुलनित्र है जो आपकी सहायता कर सकता है।

इसके अलावा, यदि आप कुछ जावा 8 नई सुविधाओं का उपयोग करना चाहते हैं, तो आप ऐसा कर सकते हैं:

List<String> yourList = new ArrayList<String>();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());

Answer 14

उदाहरण के लिए मेरे पास एक व्यक्ति है: स्ट्रिंग नाम, int उम्र ==> कंस्ट्रक्टर नया व्यक्ति (नाम, आयु)

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


public void main(String[] args){
    Person ibrahima=new Person("Timera",40);
    Person toto=new Person("Toto",35);
    Person alex=new Person("Alex",50);
    ArrayList<Person> myList=new ArrayList<Person>
    Collections.sort(myList, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            // return p1.age+"".compareTo(p2.age+""); //sort by age
            return p1.name.compareTo(p2.name); // if you want to short by name
        }
    });
    System.out.println(myList.toString());
    //[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]]
    Collections.reverse(myList);
    System.out.println(myList.toString());
    //[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]]

}

Comments

if you want to short by name->if you want to sort by name

— linrongbin

Answer 15

जावा 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())

Answer 16

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

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

Answer 17

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

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

नोट: मैं एक्लिप्स कलेक्शंस के लिए कमिट हूं ।

Answer 18

निम्न पंक्ति मोटी करनी चाहिए

testList.sort(Collections.reverseOrder());