जावा

Question

के लिए पायथन काउंटर विकल्प मैं पाइथन में काउंटर() डेटा स्ट्रक्चर का उपयोग एक महत्वपूर्ण-मूल्य स्टोर के रूप में कर रहा हूं जो मुझे ऑब्जेक्ट को सबसे मूल्यवान विधि का उपयोग करके उनके मूल्य के अनुसार सॉर्ट करने की अनुमति देता है। अधिक जानकारी here।

क्या जावा भाषा के लिए कोई समान डेटा संरचना है? उदाहरण के लिए, मैंने कई संबंधित उत्तरों को देखा है जो डेटा संरचना द्वारा HashMaps या TreeMaps को सॉर्ट करने पर ध्यान केंद्रित करते हैं, प्रारंभ में उस उद्देश्य के लिए परिभाषित नहीं किया गया है। मेरे मामले में मुझे आमतौर पर वस्तुओं के काउंटर रखने की आवश्यकता होती है और फिर सबसे आम या उच्चतम स्कोर वाले शीर्ष चयन (शीर्ष-एन प्रश्न) चुनने की आवश्यकता होती है। हालांकि, मेरे लिए यह मुश्किल है क्योंकि मुझे हैश मैप में डालने की आवश्यकता है और फिर सॉर्ट करें या एकाधिक डेटा संरचनाओं का उपयोग करें।

Answer 1

here से:

काउंटर वर्ग अन्य भाषाओं में बैग या multisets के समान है।

जावा में मल्टीसेट क्लास या एनालॉग नहीं है। अमरूद में मल्टीसेट संग्रह है, जो वही करता है जो आप चाहते हैं।

शुद्ध जावा में, आप एक नक्शा और नए मर्ज विधि का उपयोग कर सकते हैं:

final Map<String, Integer> counts = new HashMap<>(); 

counts.merge("Test", 1, Integer::sum); 
counts.merge("Test", 1, Integer::sum); 
counts.merge("Other", 1, Integer::sum); 
counts.merge("Other", 1, Integer::sum); 
counts.merge("Other", 1, Integer::sum); 

System.out.println(counts.getOrDefault("Test", 0)); 
System.out.println(counts.getOrDefault("Other", 0)); 
System.out.println(counts.getOrDefault("Another", 0)); 

आउटपुट:

2 
3 
0 

आप कोड की कुछ लाइनों में एक वर्ग में इस व्यवहार को लपेट कर सकते हैं:

public class Counter<T> { 
    final Map<T, Integer> counts = new HashMap<>(); 

    public void add(T t) { 
     counts.merge(t, 1, Integer::sum); 
    } 

    public int count(T t) { 
     return counts.getOrDefault(t, 0); 
    } 
} 

और यह इस तरह का उपयोग करें:

final Counter<String> counts = new Counter<>(); 

counts.add("Test"); 
counts.add("Test"); 
counts.add("Other"); 
counts.add("Other"); 
counts.add("Other"); 

System.out.println(counts.count("Test")); 
System.out.println(counts.count("Other")); 
System.out.println(counts.count("Another")); 

आउटपुट:

2 
3 
0 

Answer 2

यहां कक्षा कि ऐसा लगता है कि आप क्या चाहते हैं क्या करना Counter के लिए पर्याप्त लागू करता है।

static class Counter<T> { 

    final ConcurrentMap<T, Integer> counts = new ConcurrentHashMap<>(); 

    public void put(T it) { 
     add(it, 1); 
    } 

    public void add(T it, int v) { 
     counts.merge(it, v, Integer::sum); 
    } 

    public List<T> mostCommon(int n) { 
     return counts.entrySet().stream() 
       // Sort by value. 
       .sorted((e1, e2) -> Integer.compare(e1.getValue(), e2.getValue())) 
       // Top n. 
       .limit(n) 
       // Keys only. 
       .map(e -> e.getKey()) 
       // As a list. 
       .collect(Collectors.toList()); 
    } 
} 

public void test() { 
    Counter<String> c = new Counter<>(); 
    String[] numbers = {"Zero", "One", "Two", "Three", "Four", "Five", "Six"}; 
    for (int i = 0; i < numbers.length; i++) { 
     c.add(numbers[i], i); 
    } 
    System.out.println(c.mostCommon(3)); 
} 

यह जावा 8 कार्यक्षमता का उपयोग करता है।