java - संपत्ति द्वारा कस्टम ऑब्जेक्ट्स के ArrayList सॉर्ट करें




sorting date (16)

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

मैं अपनी वस्तुओं में से एक द्वारा कस्टम ऑब्जेक्ट्स के getStartDay() को सॉर्ट करना चाहता था: एक डेट ऑब्जेक्ट ( getStartDay() )। आम तौर पर मैं उन्हें item1.getStartDate().before(item2.getStartDate()) तुलना करता हूं 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);
    ...
}

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

2016 में स्टटगार्ट जर्मनी में जावा फोरम में आप इस presentation को देख सकते हैं।

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

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

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

यदि आप जावा 8 में हैं, तो आपको शुरू करने के लिए वहां बहुत सारी सामग्री मिलती है।


Java 8 उपयोग का उपयोग Comparator.comparing() का उपयोग कर एक पंक्ति में Comparator को परिभाषित कर सकते हैं

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

विकल्प 1:

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

विकल्प 2:

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

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


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

तुलना करें () को प्रश्न का उत्तर देना चाहिए: क्या ऑब्जेक्ट 1 ऑब्जेक्ट 2 के बराबर या उससे अधिक है?

पूर्ण दस्तावेज़: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html


इस पुस्तकालय के साथ आप कई कॉलम पर कस्टम ऑब्जेक्ट्स की सूची को सॉर्ट कर सकते हैं। पुस्तकालय संस्करण 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);

चूंकि Date Comparable से लागू होता है, इसकी compareTo एक String करता है जैसे 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());
    }
});

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

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

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

ये सभी समकक्ष रूप हैं।


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

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

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

क्रमबद्ध क्रमबद्ध करें

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 बार औसत), लेकिन क्या आप एक और अधिक पठनीय कोड पा सकते हैं?


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

import static java.util.Comparator.comparing;

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

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

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

दो उदाहरण:

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) {
        ...
    }
});

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

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

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

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

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

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


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

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

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

इससे Collectionssort विधि आपके सॉर्टिंग तंत्र के लिए आपके तुलनित्र का उपयोग करने का कारण बन जाएगी। यदि ArrayList में ऑब्जेक्ट तुलनीय लागू करते हैं, तो आप इसके बजाय कुछ ऐसा कर सकते हैं:

Collections.sort(myArrayList);

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


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 देखें।


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

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

or

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




comparator