[Java] जावा में क्रमबद्ध संग्रह



Answers

ट्रीमैप और ट्रीसेट आपको सॉर्ट किए गए क्रम में सामग्री पर पुनरावृत्ति देगा। या आप एक ArrayList का उपयोग कर सकते हैं और इसे क्रमबद्ध करने के लिए Collections.sort () का उपयोग कर सकते हैं। वे सभी कक्षाएं java.util में हैं

Question

मैं जावा में एक नौसिखिया हूँ। कृपया सुझाव दें कि जावा में क्रमबद्ध सूची को बनाए रखने के लिए कौन सा संग्रह उपयोग किया जा सकता है। मैंने Map और Set की कोशिश की है, लेकिन वे नहीं थे जो मैं ढूंढ रहा था।




आप SortedSet कार्यान्वयन चाहते हैं, अर्थात् SortedSet




आप Arraylist और Treemap का उपयोग कर सकते हैं, जैसा कि आपने कहा था कि आप बार-बार मूल्यों को भी चाहते हैं, फिर आप ट्रीसेट का उपयोग नहीं कर सकते हैं, हालांकि इसे सॉर्ट किया गया है, लेकिन आपको तुलनित्र को परिभाषित करना होगा।




TreeSet प्रयोग करें जो क्रमबद्ध क्रम में तत्व देता है। या Comparator() साथ बाहरी सॉर्टिंग के लिए Collection.sort() उपयोग करें।




Google Guava के TreeMultiset का प्रयोग करें। अमरूद एक शानदार संग्रह एपीआई है।

अमरूद: https://github.com/google/guava

TreeMultiset: https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/TreeMultiset.html

सॉर्ट किए गए ऑर्डर को बनाए रखने वाली सूची का कार्यान्वयन प्रदान करने में एक समस्या 'एड' विधि के जावाडॉक्स में किए गए वादे है।




मैंने जो किया है, वह सभी कार्यान्वयन के साथ एक आंतरिक उदाहरण रखने वाली सूची लागू कर रहा है।

 public class ContactList implements List<Contact>, Serializable {
    private static final long serialVersionUID = -1862666454644475565L;
    private final List<Contact> list;

public ContactList() {
    super();
    this.list = new ArrayList<Contact>();
}

public ContactList(List<Contact> list) {
    super();
    //copy and order list
    List<Contact>aux= new ArrayList(list);
    Collections.sort(aux);

    this.list = aux;
}

public void clear() {
    list.clear();
}

public boolean contains(Object object) {
    return list.contains(object);
}

इसके बाद, मैंने एक नई विधि "putOrdered" लागू की है जो उचित स्थिति में डाली गई है यदि तत्व अस्तित्व में नहीं है या बस मौजूद होने पर प्रतिस्थापित करता है।

public void putOrdered(Contact contact) {
    int index=Collections.binarySearch(this.list,contact);
    if(index<0){
        index= -(index+1);
        list.add(index, contact);
    }else{
        list.set(index, contact);
    }
}

यदि आप बार-बार तत्वों को अनुमति देना चाहते हैं तो इसके बजाय addOrdered को लागू करें (या दोनों)।

public void addOrdered(Contact contact) {
    int index=Collections.binarySearch(this.list,contact);
    if(index<0){
        index= -(index+1);
    }
    list.add(index, contact);
}

यदि आप आवेषण से बचना चाहते हैं तो आप "एड" और "सेट" विधियों पर भी फेंक और असमर्थित अपवाद अपवाद कर सकते हैं।

public boolean add(Contact object) {
    throw new UnsupportedOperationException("Use putOrdered instead");
}

... और आपको ListIterator विधियों से सावधान रहना होगा क्योंकि वे आपकी आंतरिक सूची को संशोधित कर सकते हैं। इस मामले में आप आंतरिक सूची की एक प्रति वापस कर सकते हैं या फिर एक अपवाद फेंक सकते हैं।

public ListIterator<Contact> listIterator() {
    return (new ArrayList<Contact>(list)).listIterator();
}



PriorityQueue के साथ समस्या यह है कि यह एक साधारण सरणी द्वारा समर्थित है, और तर्क जो तत्वों को क्रम में प्राप्त करता है "कतार [2 * एन + 1] और कतार [2 * (एन + 1)]" चीज द्वारा किया जाता है। यदि आप केवल सिर से खींचते हैं तो यह बहुत अच्छा काम करता है, लेकिन अगर आप किसी बिंदु पर .toArray को कॉल करने का प्रयास कर रहे हैं तो यह बेकार हो जाता है।

मैं com.google.common.collect.TreeMultimap का उपयोग करके इस समस्या के आसपास जाता हूं, लेकिन मैं ऑर्डरिंग में लिपटे मानों के लिए एक कस्टम तुलनाकर्ता प्रदान करता हूं, जो कभी 0 नहीं देता है।

पूर्व। डबल के लिए:

private static final Ordering<Double> NoEqualOrder = Ordering.from(new Comparator<Double>() {

    @Override
    public int compare(Double d1, Double d2)
    {
        if (d1 < d2) {
            return -1;
        }
        else {
            return 1;
        }
    }
});

इस तरह से मैं मूल्यों को प्राप्त करता हूं जब मैं .toArray () को कॉल करता हूं, और डुप्लिकेट भी करता हूं।




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

यदि आप जावा 8 के पूर्व संस्करणों का उपयोग कर रहे हैं तो आप इन कार्यों को 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());
        }
}); 

LambdaJ के साथ क्रमबद्ध करें

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

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

लैम्ब्डा अभिव्यक्ति का उपयोग कर जावा 8 के साथ क्रमबद्ध करें

Collections.sort(persons, (p1, p2) -> p1.getAge().compareTo(p2.getAge()));
//or
persons.sort((p1, p2) -> p1.getAge().compareTo(p2.getAge()));



Links