उलटा कलेक्टरों। मैप को एक ऐरेलिस्ट

Question

में जोड़ने के लिए मैप को TreeMap में आवृत्तियों के साथ आवृत्तियों के साथ आवृत्तियों के साथ ArrayList में आवृत्ति के साथ रखना चाहते हैं।

मैं दो समस्याओं:

1) मैं एक "गैर स्थिर तरीकों एक स्थिर संदर्भ से संदर्भित नहीं किया जा सकता" हो रही है पहले पैरामीटर में त्रुटि (AFAIK धारा एक वस्तु का संदर्भ - क्या हो रहा है?)

2) संग्राहक.टैप() के लिए 4 पैरामीटर हैं - ऐसा लगता है कि पैरामीटर 4 को एक नए TreeMap के साथ प्रारंभ करने की आवश्यकता है> पैरामीटर 2 एक ArrayList add() फ़ंक्शन और पैरामीटर 3 शून्य हो सकता है (शायद) । यह कैसे किया जाता है?

import java.util.*; 
import java.util.function.Function; 
import java.util.stream.Collectors; 

public class Main { 

    public static void main(String[] args) { 

     List<Integer> array = Arrays.asList(1, 2, 4, 5, 6, 4, 8, 4, 2, 3); 

     Map<Integer, Long> m = array.stream() 
      .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); 

     System.out.println(m); 

     TreeMap<Long, List<Integer>> tm = m.entrySet().stream() 
      .collect(Collectors.toMap(Map.Entry::getValue, ...)); 

पल मैं देख रहा हूँ कैसे https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html से जहाँ मैं होने की जरूरत को पाने के लिए उपयोग नहीं कर सकते पर

।

Answer 1

आप अपने तर्क में लगभग सही हैं ... बस 3-rd तर्क यह है कि आप एक ही कुंजी के लिए अपने मान मर्ज करते हैं - ताकि आप इसे छोड़ नहीं सकें।

TreeMap<Long, List<Integer>> tm = m.entrySet().stream() 
      .collect(Collectors.toMap(
        Entry::getValue, 
        x -> { 
         List<Integer> list = new ArrayList<>(); 
         list.add(x.getKey()); 
         return list; 
        }, 
        (left, right) -> { 
        left.addAll(right); 
        return left; 
        }, 
        TreeMap::new)); 

Answer 2

मुझे लगता है कि Collectors.groupingByCollectors.toMap की तुलना में अधिक समझ में आता है को प्राप्त करने के लिए आप क्या देख रहे हैं:

Map<Long, List<Integer>> tm = 
    m.entrySet() 
    .stream() 
    .collect(Collectors.groupingBy(Map.Entry::getValue, // group the entries by the 
                 // value (the frequency) 
            TreeMap::new, // generate a TreeMap 
            Collectors.mapping (Map.Entry::getKey, 
                 Collectors.toList()))); // the 
                 // value of the output TreeMap 
                 // should be a List of the 
                 // original keys 

आप यह सुनिश्चित करें कि उत्पादन Map के मूल्यों ArrayList रों हैं बनाने के लिए Collectors.toCollection(ArrayList::new) साथ Collectors.toList() जगह ले सकता है (हालांकि toList() का वर्तमान कार्यान्वयन पहले ही java.util.ArrayList उदाहरणों में परिणाम देता है)।

अपने नमूना इनपुट के लिए, यह निम्नलिखित TreeMap पैदा करता है:

{1=[1, 3, 5, 6, 8], 2=[2], 3=[4]} 

Answer 3

मैं उल्टे नक्शा बनाने के लिए नदियों का उपयोग नहीं होता। इसके बजाय, मैं तो बस करना होगा:

Map<Long, List<Integer>> tm = new TreeMap<>(); 
m.forEach((num, freq) -> tm.computeIfAbsent(freq, k -> new ArrayList<>()).add(num)); 

System.out.println(tm); // {1=[1, 3, 5, 6, 8], 2=[2], 3=[4]} 

के रूप में औंधा नक्शा बनाने के लिए कोड कम है, आप Collectors.collectingAndThen इस्तेमाल कर सकते हैं एक ही चरण में दोनों आवृत्तियों और उल्टे नक्शा बनाने के लिए:

TreeMap<Long, List<Integer>> invertedFrequenciesMap = array.stream() 
    .collect(Collectors.collectingAndThen(
     Collectors.groupingBy(Function.identity(), Collectors.counting()), 
     map -> { 
      TreeMap<Long, List<Integer>> tm = new TreeMap<>(); 
      map.forEach((num, freq) -> 
        tm.computeIfAbsent(freq, k -> new ArrayList<>()).add(num)); 
      return tm; 
     }));