2017-12-14 84 views
7

कहें कि मेरे पास श्रमिकों की एक सूची है, प्रत्येक श्रमिक के पास 3 फ़ील्ड हैं: इसका नाम, वह विभाग जिसमें वह काम कर रहा है (विभाग का नाम या वर्ग विभाग से ऑब्जेक्ट हो सकता है) और उसका वेतन।तुलनित्र का उपयोग कर डुप्लिकेट स्ट्रिंग्स को कैसे सॉर्ट करें?

Elvis  Software Engineering  1000 
Samba  Mechanical Engineering  2000 
Bamba  Industrial Engineering  3000 
Bisli  Medical Engineering   4000 
Kinder  Electrical Engineering  1000 
Elvis  Software Engineering  9999 

अब मैं उन्हें उनके नाम से सॉर्ट करना चाहता हूं और परिणाम को एक कतार में रखना चाहता हूं। और की तुलना में एक नक्शा, नीचे से ऊपर करने का आदेश दिया में कतार डाल तो परिणाम मैं प्रकार के बाद की इच्छा है:

Bamba  Industrial Engineering  3000 
Bisli  Medical Engineering   4000 
Elvis  Software Engineering  1000 
Elvis  Software Engineering  9999 
Samba  Mechanical Engineering  2000 
Kinder  Electrical Engineering  1000 

मैं Collection.sort() का उपयोग करने की अनुमति नहीं कर रहा हूँ, तो मैं मैं एक तुलनित्र का उपयोग कर रहा हूं जो मजदूरों को उनके नाम से टाइप करता है, यदि नाम बराबर है - विभाग द्वारा यह किया जाता है, यदि विभाग बराबर है - यह वेतन से निकलता है। यहाँ तुलनित्र मैं ने लिखा है:

Bamba  Industrial Engineering  3000 
Bisli  Medical Engineering   4000 
Elvis  Software Engineering  1000 
Samba  Mechanical Engineering  2000 
Kinder  Electrical Engineering  1000 
Elvis  Software Engineering  9999 

सभी मजदूरों हल कर रहे हैं, लेकिन एल्विस (जो दोहराया गया है) नहीं हल कर रहा है, यह में रहता है:

class WorkerComparatorByName implements Comparator<Worker<?>> { 
    @Override 
    public int compare(Worker<?> w1, Worker<?> w2) { 
     int compareValue = w1.getName().compareTo(w2.getName()); 
     if (compareValue != 0) 
      return compareValue; 
     compareValue = w1.getDepartment().toString().compareTo(w2.getDepartment().toString()); 
     if (compareValue != 0) 
      return compareValue; 
     return w1.getSalary() - w2.getSalary(); 

    } 
} 

समस्या यह है कि परिणाम यह है कतार का अंत मैंने एल्विस को एक और डुप्लिकेट नाम के साथ बदलने की कोशिश की, और एक ही परिणाम। मुझे क्या याद आ रही है? मैं डुप्लिकेट वैल्यू कैसे क्रमबद्ध कर सकता हूं ताकि वे एक के बाद एक हो जाए?

public <T extends Worker<?>> Map<?, ?> createMap(ArrayList<T> list) { 
    int i = 1; 
    // creating a PriorityQueue sorted by names 
    Queue<T> pq = new PriorityQueue<>(new WorkerComparatorByName()); 
    // filling the PriorityQueue with the workers 
    pq.addAll(list); 
    Map<Integer, T> treeMap = new TreeMap<Integer, T>(); 
    // iterating over the PriorityQueue and puting the workers in the map 
    for (T element : pq) 
     treeMap.put(i++, element); 
    return treeMap; 
} 
+0

आप प्राथमिकता क्यूई का उपयोग क्यों कर रहे हैं? यदि आप उस तुलनाकर्ता का उपयोग करके तत्वों को सॉर्ट करने के लिए डेटा संरचना चाहते हैं, तो 'TreeSet' का उपयोग करें। – Eran

+0

इस वर्ग और इसके पुनरावर्तक संग्रह और इटरेटर इंटरफेस के सभी वैकल्पिक तरीकों को लागू करते हैं। विधि इटरेटर() में दिए गए इटरेटर को किसी भी विशेष क्रम में प्राथमिकता कतार के तत्वों को पार करने की गारंटी नहीं है। यदि आपको आदेश दिया गया ट्रैवर्सल की आवश्यकता है, तो Arrays.sort (pq.toArray()) का उपयोग करने पर विचार करें। दस्तावेज़ों का संदर्भ लें: https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html –

उत्तर

2

PriorityQueue एपीआई:

इटरेटर विधि इटरेटर में प्रदान की() किसी विशेष क्रम में प्राथमिकता कतार के तत्वों पार करने के लिए गारंटी नहीं है कोड यह रहा। यदि आपको आदेश दिया गया ट्रैवर्सल की आवश्यकता है, तो Arrays.sort (pq.toArray()) का उपयोग करने पर विचार करें।

1

foreach लूप का उपयोग करने के बजाय, कतार के आइटम सामान्य for लूप और poll() का उपयोग करें।

// creating a PriorityQueue sorted by names 
Queue<T> pq = new PriorityQueue<>(new WorkerComparatorByName()); 

// filling the PriorityQueue with the workers 
pq.addAll(list); 

Map<Integer, T> treeMap = new TreeMap<Integer, T>(); 

int size = pq.size(); 
for (int j = 0; j < size; j++) { 
     treeMap.put(j + 1, pq.poll()); 
} 
+0

सभी को धन्यवाद, मैंने ट्रीसेट का उपयोग किया और तुलनित्र में परिभाषित किया कि यदि कर्मचारी समान हैं, उनमें से एक को बड़ा मानें। – Robert

0

एक स्ट्रीमिंग/लैम्ब्डा व्यायाम के रूप में इस सवाल का प्रयोग किया जाता है, यह भी कुछ जावा 8 comparing उपहार का इस्तेमाल किया। देखा कि आपने TreeSet का उपयोग करके समाप्त किया है, जो एक अच्छा समाधान है, लेकिन अगर कोई दिलचस्पी लेता है तो मैं इसे जोड़ रहा हूं।

PriorityQueue<Worker> queue = 
     new PriorityQueue<>(Comparator.comparing(Worker::getName) 
            .thenComparing(Worker::getDepartment) 
            .thenComparing(Worker::getSalary)); 
queue.addAll(list); 

TreeMap<Integer, Worker> treeMap = 
     IntStream.range(1, queue.size() + 1) 
       .boxed() 
       .collect(Collectors.toMap(Function.identity(), 
              o -> queue.poll(), 
              (u, v) -> { throw new Error("Will never happen"); }, 
              TreeMap::new)); 
संबंधित मुद्दे