दिलचस्प पोस्ट
डेटाबेस में आप प्रभावशाली मॉडल कैसे प्राप्त कर सकते हैं? jQuery: ईवेंट हैंडलर्स को बाद में फिर से बाँधने के लिए खोलें क्या एक संदर्भ एक अस्थायी जीवन को लम्बा खींचता है? एक वर्ग को विस्तारित करते समय बढ़ते त्रुटि प्रत्येक प्लॉट किए गए रेखा के लिए matplotlib में एक आकृति के भीतर एक नया रंग कैसे चुन सकता है? क्या स्विफ्ट में पहुंच संशोधक हैं? क्यों यह सरल .नेट कंसोल ऐप में इतने धागे हैं? MVC 5.1 रेजर डिस्प्ले Enum DisplayName के साथ काम नहीं कर रहा है प्रतिबिंब निजी तरीकों के विचार को तोड़ता है, क्योंकि निजी तरीकों वर्ग के बाहर का उपयोग हो सकता है? कक्षा में सभी फ़ंक्शन के लिए एक डेकोरेटर संलग्न करना पायथन के माध्यम से एक एक्सेल मैक्रो चलाना? Google मुखपृष्ठ एक iframe में लोड नहीं करेगा चाय परीक्षण सरणी समानता अपेक्षा के अनुरूप काम नहीं करती है कोका एपीआई का उपयोग करके आवेदन कैसे लाएं और सामने लाएं? कई सेट कॉलम इकट्ठा करें

ऑब्जेक्ट की सूची को सॉर्ट करने के लिए कैसे करें

मेरे पास साधारण वर्ग है

public class ActiveAlarm { public long timeStarted; public long timeEnded; private String name = ""; private String description = ""; private String event; private boolean live = false; } 

और List<ActiveAlarm> con समय पर आरोही क्रम में क्रमबद्ध कैसे करें, timeStarted , समय से? क्या कोई मदद कर सकता है? मैं सामान्य एल्गोरिथ्म और अधिभार ऑपरेटर के साथ सी ++ में जानता हूं, लेकिन मैं जावा के लिए नया हूँ

Solutions Collecting From Web of "ऑब्जेक्ट की सूची को सॉर्ट करने के लिए कैसे करें"

या तो ActiveAlarm को Comparable<ActiveAlarm> लागू करें या एक अलग कक्षा में Comparator<ActiveAlarm> को लागू करें। फिर कॉल करो:

 Collections.sort(list); 

या

 Collections.sort(list, comparator); 

सामान्य तौर पर, Comparable<T> को लागू करने का एक अच्छा विचार है यदि कोई एकल "प्राकृतिक" सॉर्ट ऑर्डर है … अन्यथा (यदि आप किसी विशेष क्रम में सॉर्ट करना चाहते हैं, लेकिन वह आसानी से एक अलग एक चाहते हैं) तो यह बेहतर है Comparator<T> को लागू करने के लिए यह विशेष स्थिति किसी भी तरह से, ईमानदार हो सकती है … लेकिन मैं शायद अधिक लचीले Comparator<T> विकल्प के साथ छड़ी करूँगा

संपादित करें: नमूना कार्यान्वयन:

 public class AlarmByTimesComparer implements Comparator<ActiveAlarm> { @Override public int compare(ActiveAlarm x, ActiveAlarm y) { // TODO: Handle null x or y values int startComparison = compare(x.timeStarted, y.timeStarted); return startComparison != 0 ? startComparison : compare(x.timeEnded, y.timeEnded); } // I don't know why this isn't in Long... private static int compare(long a, long b) { return a < b ? -1 : a > b ? 1 : 0; } } 

Comparator का उपयोग करना

उदाहरण के लिए:

 class Score { private String name; private List<Integer> scores; // +accessor methods } 

  Collections.sort(scores, new Comparator<Score>() { public int compare(Score o1, Score o2) { return o2.getScores().get(0).compareTo(o1.getScores().get(0)); } }); 

जावा 8 और उत्तर ऊपर (लम्बाई अभिव्यक्ति का उपयोग करना)

जावा 8 में, लम्बेडा एक्सप्रेशन को यह भी आसान बनाने के लिए पेश किया गया था! अपने सभी मचान के साथ एक Comparator () ऑब्जेक्ट बनाने के बजाय, आप इसे निम्नानुसार सरल कर सकते हैं: (उदाहरण के रूप में अपने ऑब्जेक्ट का उपयोग करना)

 Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.timeStarted-a2.timeStarted); 

या कम भी:

 Collections.sort(list, Comparator.comparingInt(ActiveAlarm ::getterMethod)); 

यह एक कथन निम्नलिखित के बराबर है:

 Collections.sort(list, new Comparator<ActiveAlarm>() { @Override public int compare(ActiveAlarm a1, ActiveAlarm a2) { return a1.timeStarted - a2.timeStarted; } }); 

लम्बेडा अभिव्यक्तियों के बारे में सोचें, क्योंकि आपको केवल कोड के प्रासंगिक हिस्सों में डालने की आवश्यकता होती है: विधि हस्ताक्षर और जो वापस हो जाता है

आपके प्रश्न का एक और हिस्सा कई क्षेत्रों के साथ तुलना करने के लिए किया गया था। लैम्ब्डा भाव के साथ ऐसा करने के लिए, आप two comparisons को प्रभावी ढंग से एक में जोड़कर। .thenComparing() फ़ंक्शन का उपयोग कर सकते हैं:

 Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.timeStarted-a2.timeStarted .thenComparing ((ActiveAlarm a1, ActiveAlarm a2) -> a1.timeEnded-a2.timeEnded) ); 

उपरोक्त कोड सूची द्वारा पहली बार बार timeEnded , और फिर समय के द्वारा (उन रिकॉर्ड के लिए जो एक ही समय timeStarted )।

एक अंतिम नोट: 'लंबी' या 'पूर्णांक' प्राथमिकताओं की तुलना करना आसान है, आप केवल दूसरे से एक को घटा सकते हैं यदि आप ऑब्जेक्ट्स ('लांग' या 'स्ट्रिंग') की तुलना कर रहे हैं, तो मेरा सुझाव है कि आप अपनी अंतर्निहित तुलना का उपयोग करें। उदाहरण:

 Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.name.compareTo(a2.name) ); 

संपादित करें: मुझे इंगित करने के लिए लुकास एडर के लिए धन्यवाद। .thenComparing() फ़ंक्शन।

हम सूची को दो तरीकों से सॉर्ट कर सकते हैं:

1. तुलनित्र का उपयोग करना : कई जगहों में सॉर्ट लॉजिक का उपयोग करने के लिए आवश्यक होने पर, यदि आप एक स्थान में छँटाई तर्क का उपयोग करना चाहते हैं, तो आप निम्न के रूप में एक गुमनाम आंतरिक वर्ग लिख सकते हैं, या अन्य तुलनित्र को निकालने और इसे कई जगहों में इस्तेमाल कर सकते हैं

  Collections.sort(arrayList, new Comparator<ActiveAlarm>() { public int compare(ActiveAlarm o1, ActiveAlarm o2) { //Sorts by 'TimeStarted' property return o1.getTimeStarted()<o2.getTimeStarted()?-1:o1.getTimeStarted()>o2.getTimeStarted()?1:doSecodaryOrderSort(o1,o2); } //If 'TimeStarted' property is equal sorts by 'TimeEnded' property public int doSecodaryOrderSort(ActiveAlarm o1,ActiveAlarm o2) { return o1.getTimeEnded()<o2.getTimeEnded()?-1:o1.getTimeEnded()>o2.getTimeEnded()?1:0; } }); 

हम गुणों के लिए निरर्थक जांच कर सकते हैं, अगर हम 'लांग' के बजाय 'लांग' इस्तेमाल कर सकते हैं

2. तुलनात्मक (प्राकृतिक ऑर्डरिंग) का प्रयोग करना : यदि सॉर्ट एल्गोरिदम हमेशा एक प्रॉपर्टी पर चिपकते हैं: एक क्लास लिखें जो 'कॉम्परेबल' को लागू करता है और नीचे की गई परिभाषा के अनुसार 'तुलना' विधि को ओवरराइड करता है

 class ActiveAlarm implements Comparable<ActiveAlarm>{ public long timeStarted; public long timeEnded; private String name = ""; private String description = ""; private String event; private boolean live = false; public ActiveAlarm(long timeStarted,long timeEnded) { this.timeStarted=timeStarted; this.timeEnded=timeEnded; } public long getTimeStarted() { return timeStarted; } public long getTimeEnded() { return timeEnded; } public int compareTo(ActiveAlarm o) { return timeStarted<o.getTimeStarted()?-1:timeStarted>o.getTimeStarted()?1:doSecodaryOrderSort(o); } public int doSecodaryOrderSort(ActiveAlarm o) { return timeEnded<o.getTimeEnded()?-1:timeEnded>o.getTimeEnded()?1:0; } 

}

प्राकृतिक आदेश के आधार पर सॉर्ट करने के लिए कॉल सॉर्ट विधि

 Collections.sort(list); 
 public class ActiveAlarm implements Comparable<ActiveAlarm> { public long timeStarted; public long timeEnded; private String name = ""; private String description = ""; private String event; private boolean live = false; public int compareTo(ActiveAlarm a) { if ( this.timeStarted > a.timeStarted ) return 1; else if ( this.timeStarted < a.timeStarted ) return -1; else { if ( this.timeEnded > a.timeEnded ) return 1; else return -1; } } 

यही आपको एक कठिन विचार देना चाहिए एक बार ऐसा करने के बाद, आप सूची में Collections.sort() को कॉल कर सकते हैं।

जावा 8 के बाद से यह Comparator और Lambda expressions संयोजन का उपयोग करके भी क्लीनर किया जा सकता है

उदाहरण के लिए:

 class Student{ private String name; private List<Score> scores; // +accessor methods } class Score { private int grade; // +accessor methods } 

  Collections.sort(student.getScores(), Comparator.comparing(Score::getGrade); 

जावा में आपको स्टैटिक Collections.sort विधि का उपयोग करना होगा। यहाँ कंपनी रोल ऑब्जेक्ट्स की एक सूची के लिए एक उदाहरण है, जो कि शुरू से पहले और फिर अंत में क्रमबद्ध होता है। आप आसानी से अपने स्वयं के ऑब्जेक्ट के लिए अनुकूलित कर सकते हैं

 private static void order(List<TextComponent> roles) { Collections.sort(roles, new Comparator() { public int compare(Object o1, Object o2) { int x1 = ((CompanyRole) o1).getBegin(); int x2 = ((CompanyRole) o2).getBegin(); if (x1 != x2) { return x1 - x2; } else { int y1 = ((CompanyRole) o1).getEnd(); int y2 = ((CompanyRole) o2).getEnd(); return y2 - y1; } } }); } 

सूची अब हल हो जाएगी 🙂

अमरूद की तुलना करें :

 Collections.sort(list, new Comparator<ActiveAlarm>(){ @Override public int compare(ActiveAlarm a1, ActiveAlarm a2) { return ComparisonChain.start() .compare(a1.timestarted, a2.timestarted) //... .compare(a1.timeEnded, a1.timeEnded).result(); }}); 

आप Collections.sort () को कॉल कर सकते हैं और तुलनित्र में पास कर सकते हैं, जिसे आप ऑब्जेक्ट के विभिन्न गुणों की तुलना करने के लिए लिखना चाहते हैं।

आप Collections.sort उपयोग कर सकते हैं और अपना स्वयं का Comparator<ActiveAlarm> पास कर सकते हैं

जैसा कि आप का उल्लेख कर सकते हैं:

  • अपने ऑब्जेक्ट को लागू करने योग्य तुलना करें
  • या Collections.sort करने के लिए एक Comparator पास

यदि आप दोनों करते हैं, तो Comparable को अनदेखा कर दिया जाएगा और Comparator उपयोग किया जाएगा। इससे मदद मिलती है कि मूल्य ऑब्जेक्ट्स की अपनी तार्किक Comparable जो आपके मूल्य ऑब्जेक्ट के लिए सबसे उचित प्रकार है, जबकि प्रत्येक व्यक्तिगत उपयोग के मामले में अपना स्वयं का कार्यान्वयन है