java - 有人可以向我解释一下使用stream();的这段代码的构造吗？

Question

所以我在网上找到了解决我的问题的方法，它有效，但我无法在这里想象出确切的逐步解决方案。我还想知道如何使用更基本的语言结构(例如标准 foreach 循环)来做同样的事情。

更新:所以我以某种方式得到了sorted()和filtred()的参数化方法，并且我用过滤来实现它，但不知道如何为类中应该使用通用的其余方法定义比较器排序()方法。 这是我的代码: 包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

您有接受两个参数的通用方法，第一个参数是通用 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 在一个流中完成完整的操作这是我的fav site有完美的例子

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 对象

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>>)