2017-12-29 134 views
5

इसी प्रकार के प्रश्न देखें: How to make HashMap work with Arrays as key?ArrMap को Arrays के साथ कुंजी के रूप में कैसे काम करें?

लेकिन मैं ((int key1, int key2) -> String) तरह ट्री-मैप की जरूरत है, की तुलना key1 तो key2 की तुलना।

मेरे समाधान है:

Map<int[], String> map = new TreeMap<>(Comparator. 
      <int[]>comparingInt(key -> key[0]).thenComparingInt(key -> key[1])); 

लेकिन जब मैं ((int key1, int key2, int key3) -> String की जरूरत है, मैं और अधिक लिखना चाहिए।

क्या मनमाने ढंग से लंबाई वाले सरणी के लिए तुलनात्मक उत्पन्न करने का कोई तरीका है?

+1

शायद सबसे अच्छा तरीका सिर्फ लिखने के लिए एक 'Comparator' कि वास्तव में क्या करता होगा। मुझे संदेह है कि लैम्बदास के साथ उचित और समझदारी से किया जा सकता है। यदि आप इसे लैम्ब्डा के साथ कर सकते हैं, तो इसके लिए जाएं, लेकिन व्यक्तिगत रूप से मैं नियमित जावा का उपयोग करता हूं। – Obicere

उत्तर

6

एक लूप के साथ एक तुलनात्मक चाल चलाना चाहिए। ऐसा कुछ, अगर मैं आपकी आवश्यकता को सही ढंग से समझ गया। मुझे जिक्र करना चाहिए कि यह मानता है कि सभी चाबियाँ एक ही लंबाई के हैं। उसके बाद निम्न

public static Comparator<int[]> intArrayComparator(){ 
    return (left, right) -> { 
     int comparedLength = Integer.compare(left.length, right.length); 
     if(comparedLength == 0){ 
      for(int i = 0; i < left.length; i++){ 
       int comparedValue = Integer.compare(left[i], right[i]); 
       if(comparedValue != 0){ 
        return comparedValue; 
       } 
      } 
      return 0; 
     } else { 
      return comparedLength; 
     } 
    }; 
} 

कौन सा आप की तरह कह सकते हैं:

Map<int[], String> treeMap = new TreeMap<>((o1, o2) -> { 
     for (int i = 0; i < o1.length; i++) { 
      if (o1[i] > o2[i]) { 
       return 1; 
      } else if (o1[i] < o2[i]) { 
       return -1; 
      } 
     } 

     return 0; 
    }); 
+2

पहले लंबाई की जांच करना सुनिश्चित करें। लम्बाई बराबर होती है तो केवल लूप दर्ज करें। अन्यथा, +1। – Obicere

+0

अच्छा बिंदु - मैंने देखा कि जैसा कि मैंने इसे पोस्ट किया था। मैंने धारणा को इंगित करने के लिए मूल उत्तर अपडेट किया। –

+3

@ ओबिसेर यदि आप ऐसा करते हैं तो आप समरूपता आवश्यकता तोड़ते हैं। यदि पहली सरणी लंबी है और अन्यथा (या विपरीत, जो आप चाहते हैं उसके आधार पर) में आपको '+ 1' वापस करना चाहिए)। – talex

1

आपको फ़ैक्टरी विधि है, जो एक तुलनित्र सरणियों की लंबाई और उनके मानों की तुलना कर सकता है बनाता है

Map<int[], String> treeMap = new TreeMap<>(intArrayComparator()); 

ऊपर तुलनित्र के निम्नलिखित मामले हैं:

  • वाम सही तुलना में बड़ा है: वापसी 1
  • वाम सही से छोटी है: वापसी बाईं सरणी में सूचकांक मैं -1
  • आइटम सही सरणी से एक से बड़ा है: सूचकांक पर लौट 1
  • मद मैं बाएं सरणी में दाएं सरणी से एक से छोटा है: -1
  • बाएं दाएं बराबर बराबर है: 0 लौटें;
10

के बाद से जावा-9 यह बहुत साथ सरल किया जा सकता है:

TreeMap<int[], String> map = new TreeMap<>(Arrays::compare); 
संबंधित मुद्दे