प्रॉपर्टी द्वारा कस्टम ऑब्जेक्ट्स के एरियर को क्रमबद्ध करें

Question

मैंने ArrayLists को एक तुलनित्र का उपयोग करते हुए छाँटने के बारे में पढ़ा लेकिन सभी उदाहरणों में जिन लोगों का उपयोग compareToकिया गया है वे कुछ शोधों के अनुसार स्ट्रिंग्स के लिए एक विधि है।

मैं उनके गुणों में से एक द्वारा कस्टम ऑब्जेक्ट्स के एक ArrayList को सॉर्ट करना चाहता था: एक दिनांक ऑब्जेक्ट ( getStartDay())। आम तौर पर मैं उनकी तुलना करता item1.getStartDate().before(item2.getStartDate())हूं इसलिए मैं सोच रहा था कि क्या मैं कुछ लिख सकता हूं:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}

Comments

संबंधित: stackoverflow.com/questions/1814095/…

— BalusC

इस पोस्ट में @Yishai द्वारा जवाब कस्टम छँटाई और समूहीकृत छँटाई (कई तर्क) के लिए Enum का सुरुचिपूर्ण उपयोग तुलनित्र जंजीरों का उपयोग दर्शाता है।

— गनमेल सेप

Answer 1

Dateलागू होने के बाद से Comparable, यह एक compareToविधि की तरह Stringहै।

तो आपका रिवाज Comparatorइस तरह दिख सकता है:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

compare()विधि एक लौटना चाहिए int, ताकि आप सीधे एक वापसी नहीं कर सकता booleanहै जैसे आप वैसे भी करने की योजना बना रहे थे।

आपका सॉर्टिंग कोड जैसा आपने लिखा है वैसा ही होगा:

Collections.sort(Database.arrayList, new CustomComparator());

यह सब लिखने के लिए एक छोटा सा तरीका है, अगर आपको अपने तुलनित्र का पुन: उपयोग करने की आवश्यकता नहीं है, तो इसे इनलाइन अनाम वर्ग के रूप में लिखना है:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

---

जबसे जावा-8

अब आप एक का उपयोग करके एक छोटा रूप में पिछले उदाहरण लिख सकते हैं लैम्ब्डा अभिव्यक्ति के लिए Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

और Listएक sort(Comparator)विधि है, तो आप इसे आगे भी छोटा कर सकते हैं:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

यह एक ऐसा सामान्य मुहावरा है जिसमें एक कुंजी के साथ एक वर्ग के लिए उत्पन्न करने की एक अंतर्निहित विधि है :ComparatorComparable

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

ये सभी समान रूप हैं।

Comments

+1 यह उल्लेख करने के लिए कि यह वापस आ जाना चाहिए intऔर इसके लिए आप इसका उपयोग करना बेहतर समझेंगे Date#compareTo()। यह अन्य उत्तर से ऊपर क्यों नहीं है, यह मेरे से परे है। यह लिंक उपयोगी भी हो सकता है: Sun.com पर ऑब्जेक्ट ऑर्डरिंग ट्यूटोरियल ।

— बालुसक

मुझे लगता है कि उत्तर में इसे करने का उचित तरीका भी शामिल होना चाहिए। 8. संग्रह। संग्रह (सूची, तुलनात्मक डॉटपरिंग (MyObject :: getStartDate)); जो बेहतर पढ़ता है और कम त्रुटि वाला है। Return o1.getStartDate () लिखना बहुत आसान है। तुलना करें (o1.getStartDate ());

— कुबा

तुलनित्र वर्ग स्थिर होना चाहिए :)

— जरमेज़ दे ला रोचा

@ क्यूबा बेहतर अभी तक, का उपयोग करें List.sort()।

— शमोसल

यह समाधान Android API <24 पर काम नहीं करता है। क्या आप लोग इसके लिए कोई समाधान जानते हैं?

— जिम

Answer 2

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

दो उदाहरण:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

उपयोग:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

Comments

मैंने कोशिश की है कि - लेकिन जब मैं किसी अन्य वर्ग के बाहर तुलनित्र वर्ग के अध्यक्ष WeightComparator तक पहुंचना चाहता हूं तो मुझे इस वर्ग तक पहुंच नहीं मिलती है (निश्चित रूप से इसके सार्वजनिक नहीं होने के बाद से)। क्या मुझे एक अलग फ़ाइल में एक नया सार्वजनिक चेयरकार WeightComparator वर्ग बनाने की आवश्यकता है? - क्या मैं वास्तव में 3 साल बाद ऐसा करने वाला पहला व्यक्ति हूं या मुझे sth याद नहीं है?

— user387184

@ user387184 - बस इसे सार्वजनिक करें, और इसे स्वयं की फ़ाइल में डालें (अधिमानतः यह अपना पैकेज भी है) और आप इसे हर जगह अपने प्रोजेक्ट में उपयोग कर पाएंगे। अतिरिक्त कक्षा बनाने की आवश्यकता नहीं है!

— ब्योर्न

आपका मतलब है कि एक नई फ़ाइल बनाएं - क्लास नहीं और कोड में डालें: "क्लास चेयरवेट कॉमपैरेटर इम्प्लीमेंट्स <चेयर> {...."?

— user387184

@ user387184, बिल्कुल - लेकिन publicसामने महत्वपूर्ण शब्द के साथ class।

— ब्योर्न

Answer 3

छँटाई के लिए ArrayListआप निम्नलिखित कोड स्निपेट का उपयोग कर सकते हैं:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

Comments

किसी का उपयोग कर लैम्ब्डा stackoverflow.com/questions/2784514/...

— सॉर्टर

ऐसा लगता है लेकिन प्रत्येक तत्व के लिए दोहरा मूल्य देता है

— सैम

Answer 4

हाँ तुम कर सकते हो। आइटम की तुलना करने के साथ दो विकल्प हैं, तुलनात्मक इंटरफ़ेस, और कम्पैरिलेटर इंटरफ़ेस।

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

Collections.sort(myArrayList, new MyComparator());

इसके लिए यह छँटाई तंत्र के लिए अपने तुलनित्र का उपयोग करने के लिए Collections.sort विधि का कारण होगा। यदि ArrayList में वस्तुएँ तुलनीय हैं, तो आप इसके बजाय कुछ ऐसा कर सकते हैं:

Collections.sort(myArrayList);

संग्रह वर्ग इन उपयोगी, आम उपकरणों की एक संख्या में शामिल है।

Answer 5

JAVA 8 लंबोदर अभिव्यक्ति

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

या

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

Comments

याCollections.sort(studList, Comparator.comparing(Student::getFirstName));

— Holger

.. याstudList.sort(Comparator.comparing(Student::getFirstName));

— एलेक्सिस सी।

सॉर्ट क्रम हमेशा आपके मामले में आरोही होगा। मैंने अपने उदाहरण में क्रमबद्ध क्रम का भी ध्यान रखा है। धन्यवाद सज्जनों।

— सॉर्टर

Answer 6

जावा 8 के साथ आप अपने तुलनित्र के लिए एक विधि संदर्भ का उपयोग कर सकते हैं:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

Comments

@ user387184 दुर्भाग्यवश एंड्रॉइड जावा 8 का समर्थन नहीं करता है, हालांकि वर्कअराउंड हो सकता है (मैंने इसका परीक्षण नहीं किया है)।

— अस्सलासी

Answer 7

चूंकि प्रौद्योगिकियां हर रोज दिखाई देती हैं, इसलिए उत्तर समय में बदल जाएगा। मैंने लंबोदर पर एक नज़र डाली और बहुत दिलचस्प लगता है।

आप इन कार्यों को लेम्बडाज के साथ हल करने का प्रयास कर सकते हैं । आप इसे यहां देख सकते हैं: http://code.google.com/p/lambdaj/

यहाँ आपके पास एक उदाहरण है:

क्रमबद्ध Iterative

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

लंबोदर के साथ छाँटें

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

बेशक, प्रदर्शन में इस तरह का सौंदर्य प्रभाव पड़ता है (औसत 2 बार), लेकिन क्या आप अधिक पठनीय कोड पा सकते हैं?

Comments

इस प्रकार, लेकिन प्रत्येक तत्व के लिए दोहरा मूल्य देता है कि इसे कैसे बचा जाए

— सैम

@, यह नहीं होना चाहिए ... यह उम्मीद के मुताबिक काम कर रहा है। जब तक आप बग के साथ एक नया संस्करण का उपयोग नहीं कर रहे हैं, जो मैं आपको इसे मंच में पोस्ट करने की सलाह देता हूं। वैसे भी, यह उत्तर जावा 8 से पहले पोस्ट किया गया था, यदि आप इसका उपयोग करते हैं, तो यह लैम्ब्डाज का उपयोग करने की तुलना में बहुत बेहतर होगा

— फेडेरिको पियाजा

मुझे एक फारच्यू लूप में भी वस्तुओं को निकालना पड़ा जो अन्य बुद्धिमान है जो मुझे प्रत्येक सामग्री का दोगुना देता है।

— सैम

Answer 8

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}

Comments

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

— Leigh

कृपया अपने उत्तर में स्पष्टीकरण जोड़ें।

— अरशसॉफ्ट

बस संकलित करें और चलाएं। कोड टिप्पणी और स्पष्टीकरण है।

— 13

Answer 9

JAVA 8 के साथ सबसे अच्छा आसान तरीका अंग्रेजी वर्णमाला प्रकार के लिए है

कक्षा कार्यान्वयन

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

तरह

  Collections.sort(Your List);

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

कक्षा कार्यान्वयन

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

तरह

Collections.sort(your array list,new NewspaperClass());

Answer 10

समारोह और विधि संदर्भ

Collections.sortविधि एक सॉर्ट कर सकते हैं Listएक का उपयोग कर Comparatorआप गुजरती हैं। यह उस पद्धति Comparatorका उपयोग करके लागू किया जा सकता है Comparator.comparingजहां आप आवश्यक के रूप में एक विधि संदर्भ पास कर सकते हैं Function। सौभाग्य से, वास्तविक कोड इस विवरण से बहुत सरल और छोटा है।

जावा 8 के लिए:

Collections.sort(list, comparing(ClassName::getName));

या

Collections.sort(list, comparing(ClassName::getName).reversed());

दूसरा तरीका है

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

Comments

कॉल के लिए एपीआई स्तर 24 की आवश्यकता होती है

— 12

Answer 11

से Java 8और आगे हम उपयोग करने के लिए की जरूरत नहीं है Collections.sort()सीधे। Listइंटरफ़ेस में एक डिफ़ॉल्ट sort()विधि है:

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

Http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html देखें ।

Answer 12

जावा 8 लैंबडा इस प्रकार को छोटा करता है।

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

Comments

Collections.sort(stdList, Comparator.comparing(SomeClass::getName));

— bcsb1001

Answer 13

आप अपने कस्टम वर्ग में किसी भी संपत्ति पर सॉर्ट करने के लिए बीन तुलनित्र का उपयोग कर सकते हैं ।

Answer 14

हां, इस उत्तर में उदाहरण के लिए संभव है कि मैं vवर्ग की संपत्ति के आधार पर छांटता हूंIndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

यदि आप यहाँ नोटिस करते हैं तो मैं एक अनाम आंतरिक वर्ग (जो क्लोज़र के लिए जावा है) बना रहा हूँ और इसे सीधे sortकक्षा की विधि में पास कर रहा हूँArrays

आपकी वस्तु भी लागू हो सकती है Comparable(जो कि स्ट्रिंग और जावा में अधिकांश मुख्य पुस्तकालय करता है) लेकिन यह स्वयं के वर्ग के "प्राकृतिक क्रम क्रम" को परिभाषित करेगा, और आपको नए प्लग नहीं करने देगा।

Comments

... लेकिन जो आप बस के साथ ओवरराइड कर सकते हैं Comparator:)

— BalusC

Answer 15

मैंने पाया कि यदि ये सभी उत्तर तुलनीय को लागू करने के लिए अंतर्निहित वर्ग (वस्तु) पर निर्भर हैं या सहायक तुलनीय इंटरफ़ेस है।

मेरे समाधान के साथ नहीं! निम्न कोड आपको उनके स्ट्रिंग नाम को जानकर ऑब्जेक्ट के क्षेत्र की तुलना करने देता है। आप आसानी से इसे संशोधित कर सकते हैं कि नाम का उपयोग न करें, लेकिन फिर आपको इसे उजागर करने या उन वस्तुओं में से एक का निर्माण करने की आवश्यकता है जिनके खिलाफ आप तुलना करना चाहते हैं।

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}

Answer 16

आप अमरूद ऑर्डर करने की कोशिश कर सकते हैं :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

Answer 17

आप java 8 का उपयोग करके सॉर्ट कर सकते हैं

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));

Answer 18

यह कोड स्निपेट उपयोगी हो सकता है। यदि आप मेरे मामले में किसी वस्तु को छाँटना चाहते हैं, तो मैं वॉल्यूमनैम द्वारा छाँटना चाहता हूँ:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

यह काम। मैं इसे अपने जेएसपी में उपयोग करता हूं।

Answer 19

इस लाइब्रेरी के साथ यहां आप कई कॉलम पर कस्टम ऑब्जेक्ट की सूची को सॉर्ट कर सकते हैं। पुस्तकालय संस्करण 8.0 की सुविधाओं का उपयोग करता है। वहां नमूना भी उपलब्ध है। यहाँ एक नमूना है

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);

Answer 20

आप 2016 में स्टटगार्ट जर्मनी में जावा फोरम में इस प्रेजेंटेशन होल्ड पर नज़र डाल सकते हैं ।

कुछ ही स्लाइड जर्मन भाषा का उपयोग करते हैं, सामग्री का 99% "अंग्रेजी आधारित" जावा स्रोत कोड है; पसंद

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

कहाँ पे OurCustomComparator डिफ़ॉल्ट विधियों (और अन्य दिलचस्प विचारों) का उपयोग किया जा रहा है। जैसा कि दिखाया गया है, छँटाई के लिए कुछ गेटर विधि चुनने के लिए बहुत संक्षिप्त कोड के लिए अग्रणी; और सॉर्ट मानदंड का सुपर सरल चेनिंग (या उलट)।

यदि आप java8 में हैं, तो आपको आरंभ करने के लिए बहुत सारी सामग्री मिलती है।

Answer 21

1.8 के बाद से नया संग्रह.शॉर्ट () के बजाय List.sort () विधि है, इसलिए आप सीधे mylistcontainer.sort () कहते हैं।

यहां एक कोड स्निपेट दिया गया है, जो लिस्ट.सॉर्ट () सुविधा प्रदर्शित करता है:

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

फल वर्ग है:

public class Fruit implements Comparable<Fruit>
{
    private String name;
    private String color;
    private int quantity;

    public Fruit(String name,String color,int quantity)
    { this.name = name; this.color = color; this.quantity = quantity; }

    public String getFruitName() { return name; }        
    public String getColor() { return color; }  
    public int getQuantity() { return quantity; }

    @Override public final int compareTo(Fruit f) // sorting the color
    {
        return this.color.compareTo(f.color);
    }     
    @Override public String toString()
    {   
        return (name + " is: " + color);
    }
} // end of Fruit class   

Answer 22

आपके customComparator वर्ग का उपयोग करने के लिए java.util.Comparator को लागू करना होगा। यह भी तुलना करना चाहिए () और बराबर ()

तुलना () प्रश्न का उत्तर देना चाहिए: क्या वस्तु १, वस्तु २ से कम या अधिक है?

पूर्ण डॉक्स: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Answer 23

मैं इस प्रक्रिया को पसंद करता हूं:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

यदि आप वस्तुओं की सूची में एक संपत्ति कहते हैं startDate, तो आप इस उपयोग को बार-बार कहते हैं। आप उन्हें चेन भी कर सकते हैं startDate.time।

यह आपके वस्तु होने की आवश्यकता है Comparableजिसका अर्थ है कि आप एक की जरूरत है compareTo, equalsऔर hashCodeकार्यान्वयन।

हां, यह तेज हो सकता है ... लेकिन अब आपको प्रत्येक प्रकार के लिए एक नया तुलनित्र बनाने की आवश्यकता नहीं है। यदि आप देव समय पर बचा सकते हैं और रनटाइम को छोड़ सकते हैं, तो आप इस के साथ जा सकते हैं।

Comments

1, यह जवाब 2 घंटे पहले दिए गए वर्किंग कोड के साथ दिया गया था। एक ही समाधान को फिर से तैयार करने और मंच को अव्यवस्थित करने की आवश्यकता नहीं है, खासकर बीनकॉमपरेटर एक मानक वर्ग नहीं है, इसलिए इसका वास्तव में समाधान नहीं है यदि पोस्टर को नहीं पता है कि आप किस बारे में बात कर रहे हैं। यदि आपको मूल सुझाव पसंद है तो आप इसे बढ़ा सकते हैं और यदि आप चाहें तो टिप्पणी जोड़ सकते हैं।

— camickr

Answer 24

जावा 8 के उपयोग से परिभाषित किया जा सकता है Comparator का उपयोग करके एक लाइन मेंComparator.comparing()

निम्नलिखित में से किसी भी तरीके का उपयोग करें:

विकल्प 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

विकल्प 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));

Comments

3 साल पहले से इस उत्तर का डुप्लिकेट लगता है ।

— तुलसी बॉर्क

बिल्कुल नहीं, केवल विकल्प 2 यहां दिए गए उत्तर में विकल्प 1 के समान है। मुझे लगता है कि दो अलग-अलग उत्तरों में कुछ समानताएँ हो सकती हैं यदि वे एक ही प्रश्न का उत्तर दें।

— साहिल छाबड़ा

Answer 25

आपका कस्टम वर्ग "तुलनात्मक" इंटरफ़ेस को लागू कर सकता है, जिसके लिए ComparTo पद्धति के कार्यान्वयन की आवश्यकता है। तुलना विधि में, आप तब परिभाषित कर सकते हैं कि इसका क्या अर्थ है कि एक वस्तु अन्य वस्तु से कम या अधिक है । तो आपके उदाहरण में, यह कुछ इस तरह दिख सकता है:

public class MyCustomClass implements Comparable<MyCustomClass>{

..........

 @Override
public int compareTo(MyCustomClass a) {
    if(this.getStartDate().before(a.getStartDate())){
        return -1;
    }else if(a.getStartDate().before(this.getStartDate())){
        return 1;
    }else {
        return 0;
    }
}

एक नकारात्मक संख्या इंगित करती है कि यह वस्तु की तुलना में छोटा है। एक सकारात्मक संख्या इंगित करती है कि यह वस्तु की तुलना में बड़ा है और एक शून्य का मतलब है कि वस्तुएं समान हैं।

तब आप किसी सूची में फीडर के बिना अपनी सूची को सॉर्ट करने के लिए collection.sort (myList) का उपयोग कर सकते हैं। यदि आप किसी ट्रीसैट या ट्रीपैप जैसे सॉर्ट किए गए संग्रह डेटा संरचनाओं का उपयोग करते हैं, तो इस पद्धति का अपने आप सॉर्ट किए जाने का लाभ है।

यदि आप तुलनात्मक इंटरफ़ेस (प्रकटीकरण: मैं लेखक हूँ;) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-colorsions/ के बारे में अधिक जानना चाहते हैं, तो आप इस लेख को देख सकते हैं।

Answer 26

आप स्प्रिंग्स प्रॉपर्टीकंपेटर का उपयोग भी कर सकते हैं यदि आपके पास केवल (स्ट्रिंग) संपत्ति है जिसे आप छाँटना चाहते हैं:

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

दोष यह है कि यह तुलनित्र चुपचाप उन गुणों की उपेक्षा करता है जो मौजूद नहीं हैं या सुलभ नहीं हैं और इसे तुलना के लिए शून्य मान के रूप में संभालता है । इसका मतलब है, आपको ध्यान से इस तरह के एक तुलनित्र का परीक्षण करना चाहिए या किसी तरह संपत्ति पथ के अस्तित्व को मान्य करना चाहिए।

Answer 27

java-8 स्ट्रीम एपीआई का उपयोग करके आप इसके ArrayListद्वारा हल कर सकते हैं :

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());

Answer 28

मैंने इंटरनेट पर उपलब्ध विभिन्न समाधानों की बहुत कोशिश की है, लेकिन मेरे लिए काम करने वाला समाधान नीचे दिए गए लिंक पर उपलब्ध है।

https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html