有人可以向我解釋使用stream（）的此代碼的構造嗎？

Question

因此，我在網上找到了解決我的問題的解決方案，並且可行，但是我無法在此處直觀地看到確切的分步解決方案。 我也想知道如何使用語言的更多基本結構（例如標准foreach循環）來做同樣的事情。

更新：所以我以某種方式了解了sorted（）和filtred（）的參數方法，並通過過濾使其實現，但不知道如何為應該使用通用sorted（）的類中其余方法定義比較器方法。 這是我的代碼：package zad1;

 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.*;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

public class ProgLang {

public LinkedHashMap<String, List<String>> ProgsMap = new LinkedHashMap<>();
public LinkedHashMap<String, List<String>> LangMap = new LinkedHashMap<>();
List<String> langs;
List<String> programmers;


public ProgLang(String file) {

    Pattern pattern = Pattern.compile("([A-Za-z0-9#+]+[\t[A-Za-z'-]+]+)");

    try {

        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        String lang = bufferedReader.readLine();

        while (lang != null) {

            if (pattern.matcher(lang).find()) {


                String[] elements = lang.split("\t");
                langs = new ArrayList<String>();

                if (!langs.contains(elements[0])) {
                    langs.add(elements[0]);
                }
                programmers = new ArrayList<String>();

                for (int k = 1; k < elements.length; k++) {
                    programmers.add(elements[k]);
                }
                LangMap.put(elements[0], programmers);

                List<String> tmp_prog = new ArrayList<>();

                for (String programmer : programmers) {
                    for (String language : langs) {

                        if (ProgsMap.get(programmer) == null) {

                            ProgsMap.put(programmer, new ArrayList<>());
                            ProgsMap.get(programmer).add(language);
                        } else if (ProgsMap.get(programmer) != null) {

                            if (!ProgsMap.get(programmer).contains(language)) {
                                ProgsMap.get(programmer).add(language);
                            }
                        }
                    }
                }

                lang = bufferedReader.readLine();


            } else
                lang = bufferedReader.readLine();
        }


        System.out.println(ProgsMap);
        System.out.println("---------");
        System.out.println(LangMap);
        bufferedReader.close();

    } catch (IOException e) {
        e.getMessage();
        System.out.println(e.getMessage());
    }

}

public LinkedHashMap<String, List<String>> getLangsMap() {
    return LangMap;
}


public LinkedHashMap<String, List<String>> getProgsMap() {
    return ProgsMap;
}


public static <K, V> LinkedHashMap<K, List<V>> sorted(Map<K, List<V>> mapToSort, Comparator<Map.Entry<K, List<V>>> entryComparator) {

    LinkedHashMap<K, List<V>> sorted = new LinkedHashMap<>();
    mapToSort.entrySet().stream().sorted(entryComparator).forEach(kListEntry -> sorted.put(kListEntry.getKey(), kListEntry.getValue()));
    //przekazuje mape jako strumien informacji gdzie kazde z wejsc do mapy 
  tj. kazda para jest obslugiwana po kolei dzieki metodzie forEach za pomoca 
  podanego w parametrach comparatora
    return sorted;
   }
  // zrodlo pomocniecze: Java Coding Problems: Improve your Java Programming 
    skills by solving real-world Coding Challanges
    //Autor Anghel Leonard

  public static <K, V> LinkedHashMap<K, List<V>> filtered(Map<K, List<V>> 
   mapToFilter, Predicate<Map.Entry<K, List<V>>> entryPredicate) {

    LinkedHashMap<K, List<V>> filteredMap = new LinkedHashMap<>();
    mapToFilter.entrySet().stream().filter(entryPredicate).forEach(entry - 
  > filteredMap.put(entry.getKey(), entry.getValue()));
    return filteredMap;

   }

  public LinkedHashMap<String, List<String>> 
  getLangsMapSortedByNumOfProgs() 
 {
      sorted(LangMap, );
  }

  public LinkedHashMap<String, List<String>> 
  getProgsMapSortedByNumOfLangs() 
 {
      sorted(ProgsMap, //what next??????? how to definea comparator to 
  sort 
     given LinkedHashMap by the size of list in every entry?);
   }

     public LinkedHashMap<String,List<String>> 
     getProgsMapForNumOfLangsGreaterThan(int value){
       return filtered(ProgsMap, entry -> entry.getValue().size() > 
  value);
      }

  }

Answer 1

您具有接受兩個參數的通用方法，第一個是具有鍵anytype和anytype值列表的通用Map

Map<any,List<any>>
Map<String, List<Integer>> map = Map.of();

第二個是對應於Map類型的通用Comparator對Map進行排序

Comparator<Map.Entry<String, List<Integer>>> com = Comparator.comparing(Map.Entry::getKey);

在該方法中，您正在對輸入Map進行排序並將其添加到LinkedHashMap以保存排序的順序

mapToSort.entrySet().stream().sorted(entryComparator).forEach(kListEntry -> sorted.put(kListEntry.getKey(), kListEntry.getValue()));

因此，您可以使用Collectors.toMap在一個流中完成完整的操作，這是我最喜歡的網站，上面有完美的示例

public static <K, V> Map<K, List<V>> sorted(Map<K, List<V>> mapToSort,
        Comparator<Map.Entry<K, List<V>>> entryComparator) {

    LinkedHashMap<K, List<V>> sorted = mapToSort.entrySet().stream().sorted(entryComparator)
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

    return sorted;
}

您還可以傳遞不同類型的不同地圖對象

Map<Integer, List<String>> map = Map.of();
Map<Double, List<Integer>> map = Map.of();

但是，如果您嘗試像這樣傳遞不同的合約Map和Comparator ，則會出現編譯時錯誤

Map<String, Integer> map = Map.of();
Comparator<Map.Entry<String, Integer>> com = Comparator.comparing(Map.Entry::getKey);

錯誤：

 The method sorted(Map<K,List<V>>, Comparator<Map.Entry<K,List<V>>>) in the type 
 Class is not applicable for the arguments (Map<String,Integer>, Comparator<Map.Entry<String,Integer>>)

Answer 2

映射由鍵值對組成，例如：

// key: value
   name: John
   surname: Smith

這樣，每個鍵值對都稱為一個條目。

在這里，我們使用該映射，將條目轉換為流，並處理這些條目。

在這種情況下，我們有以下內容：

將地圖轉換為條目：

(name, John), (surname, Smith)

根據提供的比較器對條目進行排序（例如，降序字母鍵值）

(surname, Smith), (name, John) 

然后將它們分別添加到已排序的映射中，以獲取鍵和值。

在這種情況下，我們將按一定順序將鍵輸入到LinkedHashMap中。 為什么要執行此操作取決於您要解決的問題，該問題可能與Java對LinkedHashMap的實現和條目排序有關，以提高性能。

看來這是一個非常特殊的問題，也許您可​​以填寫這些內容以提供更多信息。