जावा अपनी key.length द्वारा, तरह हैश नक्शा() में

Question

मैं इस तरह एक hashmap है:

HashMap<String,Integer> map = new HashMap<String,Integer>(); 
map.put("java",4); 
map.put("go",2); 
map.put("objective-c",11); 
map.put("c#",2); 

अब मैं, उसके प्रमुख लंबाई से इस नक्शे को सॉर्ट करने अगर दो कुंजी लंबाई बराबर हैं चाहते हैं (उदाहरण के लिए जाओ और सी # दोनों लंबाई 2), फिर अल्फा आदेश द्वारा क्रमबद्ध। तो परिणाम मैं प्राप्त करने की उम्मीद है कुछ की तरह:

मुद्रित परिणाम: उद्देश्य-सी, 11 जावा, 4 सी #, 2 जाना, 2

यहाँ मेरे अपने attamp है, लेकिन यह does not बिल्कुल काम ...

 HashMap<String,Integer> map = new HashMap<String,Integer>(); 
      map.put("java",4); 
      map.put("go",2); 
      map.put("objective-c",11); 
      map.put("c#",2); 

     Map<String,Integer> treeMap = new TreeMap<String, Integer>(
       new Comparator<String>() { 
        @Override 
        public int compare(String s1, String s2) { 
         return s1.length().compareTo(s2.length()); 
        } 
       } 
     ); 

वास्तव में 'compareTo' विधि (नहीं संकलन करने में सक्षम हो) लाल के रूप में प्रकट .... कोई कुछ कोड उदाहरण के साथ मेरी मदद कृपया ... मैं थोड़ा भ्रमित कर रहा हूँ कॉम्पा को अनुकूलित करने के लिए तुलनित्र वर्ग का उपयोग कैसे करें ऑब्जेक्ट ...

Answer 1

Integer.compare(s1.length(), s2.length()); अद्यतन कोड का उपयोग संकलक शिकायत कर रहा है क्योंकि आप एक int पर compareTo फोन नहीं कर सकते हैं।

Map<String, Integer> treeMap = new TreeMap<String, Integer>(
    new Comparator<String>() { 
     @Override 
     public int compare(String s1, String s2) { 
      if (s1.length() > s2.length()) { 
       return -1; 
      } else if (s1.length() < s2.length()) { 
       return 1; 
      } else { 
       return s1.compareTo(s2); 
      } 
     } 
}); 

पहले दो की स्थिति दो String रों की लंबाई की तुलना और तदनुसार एक सकारात्मक या नकारात्मक संख्या वापसी: मानचित्र सॉर्ट करने के लिए सही तरीका निम्न है। तीसरी स्थिति String की शब्दावली से तुलना करेगी यदि उनकी लंबाई बराबर होती है।

Answer 2

क्योंकि length()compareTo विधि को परिभाषित नहीं करता है कि आपको त्रुटि क्यों दिखाई देती है। सही करने के लिए इसे नीचे

import java.util.Comparator; 
import java.util.HashMap; 
import java.util.Map; 
import java.util.TreeMap; 

public class Test { 

    public static void main(String[] args) { 

     HashMap<String,Integer> map = new HashMap<String,Integer>(); 
     map.put("java",4); 
     map.put("go",2); 
     map.put("objective-c",11); 
     map.put("c#",2); 


     Map<String,Integer> treeMap = new TreeMap<String, Integer>(
       new Comparator<String>() { 
        @Override 
        public int compare(String s1, String s2) { 
         return Integer.compare(s1.length(), s2.length()); 
        } 
       } 
     ); 

     treeMap.putAll(map); 

     System.out.println(treeMap); 
    } 
} 

Answer 3

तुलनाकारी होना चाहिए:

new Comparator<String>() { 
    @Override 
    public int compare(String s1, String s2) { 
     return Integer.compare(s1.length(), s2.length()); 
    } 
} 

Answer 4

आप String#length() है, जो एक आदिम int रिटर्न कहते हैं। आपको स्थिर विधि Integer.compare(int,int) की आवश्यकता है।

Map<String,Integer> treeMap = new TreeMap<>(
     Comparator.comparingInt(String::length) 
        .thenComparing(Function.identity())); 

Answer 5

तो ट्री-मैप का उपयोग कर नहीं अनिवार्य

Explantion है: आप जावा 8 पर हैं, तो आप अपने आप को लिखने का बहुत सा बचा सकता है एक Comaprator को परिभाषित करें, और अगला चरण, एक सूची परिभाषित करें ताकि हम सभी मानचित्र प्रविष्टियों को एक सूची में जोड़ सकें।

Comparator<Map.Entry<String,Integer>> byMapValues = 
     (Map.Entry<String,Integer> left, Map.Entry<String,Integer> right) ->left.getValue().compareTo(right.getValue()); 

List<Map.Entry<String,Integer>> list = new ArrayList<>(); 
list.addAll(map.entrySet()); 
Collections.sort(list, byMapValues); 
list.forEach(i -> System.out.println(i)); 

आउटपुट:

c#=2 
go=2 
java=4 
objective-c=11 

नोट: अंत में, परिभाषित Comaprator

कोड द्वारा क्रमित संख्या

के अनुसार क्रमबद्ध करने के अगर वहाँ तुलना करने की जरूरत है कुंजी के आधार पर, निम्नलिखित पंक्ति का उपयोग किया जा सकता है।

Comparator<Map.Entry<String,Integer>> byMapKeys = 
      (Map.Entry<String,Integer> left, Map.Entry<String,Integer> right) -> left.getKey().compareTo(right.getKey()); 

Answer 6

 public int compare(String o1, String o2) { 
      return o1.length() == o2.length() ? o1.compareTo(o2) : o1.length() - o2.length(); 
     }