Java 如何将键和值排序到升序列表中的树映射？

所以这个程序给出了每个单词的词频。我需要用这些数据做一个列表，按升序排列这些单词

import java.util.*;

public class A1E5{
  public static void main(String[] args) {
    // Set text in a string
    String text = "Good morning. Have a good class. " +
      "Have a good visit. Have fun!";

    // Create a TreeMap to hold words as key and count as value
    Map<String, Integer> map = new TreeMap<>();

    String[] words = text.split("[\\s+\\p{P}]");
    for (int i = 0; i < words.length; i++) {
      String key = words[i].toLowerCase();

      if (key.length() > 0) {
        if (!map.containsKey(key)) {
          map.put(key, 1);
        }
        else {
          int value = map.get(key);
          value++;
          map.put(key, value);
        }
      }
    }

    // Display key and value for each entry
    map.forEach((k, v) -> System.out.println(k + "\t" + v));
  }
}

import java.util.*；
公共等级A1E5{
公共静态void main（字符串[]args）{
//在字符串中设置文本
String text=“早上好，好好上课。”+
“祝你参观愉快，玩得开心！”；
//创建一个树形图，将单词作为键保存，并将其作为值计算
Map Map=newtreemap（）；
String[]words=text.split（“[\\s+\\p{p}]”）；
for（int i=0；i0）{
如果（！map.containsKey（键））{
地图放置（图例1）；
}
否则{
int value=map.get（键）；
值++；
map.put（键、值）；
}
}
}
//显示每个条目的键和值
map.forEach（（k，v）->System.out.println（k+“\t”+v））；
}
}

在java中实现Comparator接口并重写其比较方法。 获取集合中的map.entrySet（），将其转换为list（我们已将集合转换为list，因为集合的排序方法只能接受list类型作为参数）。 调用Collections.sort和pass list[即listOfentrySet]作为参数。 Collections.sort在内部调用Arrays.sort，Arrays.sort（）在内部调用Merge-sort。Merge-sort调用Comparator接口的compare方法来比较键。最终，listOfentrySet将包含基于java键排序的条目（键值）对

这是一个简单的谷歌搜索，但您可以：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;



class SortByKeyAscending implements Comparator<Map.Entry<Integer, Integer>>{

@Override
public int compare( Map.Entry<Integer,Integer> entry1, Map.Entry<Integer,Integer> entry2){
    return (entry1.getKey()).compareTo( entry2.getKey() );
    }
}



public class SortMapByKeyAscendingExample {

public static void main(String...a){
    Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
    map.put(4, 1);
    map.put(2, 1);
    map.put(3, 1);
    map.put(5, 1);

    Set<Entry<Integer, Integer>> entrySet = map.entrySet();
    List<Entry<Integer, Integer>> listOfentrySet = new ArrayList<Entry<Integer, Integer>>(entrySet);

    System.out.print("Before sorting by key : ");
    for(Map.Entry<Integer, Integer> entry:listOfentrySet){
     System.out.print(entry.getKey()+"="+entry.getValue()+"  ");
    }

    Collections.sort(listOfentrySet, new SortByKeyAscending());


    System.out.print("\nAfter sorting by key(ascending): ");
    for(Map.Entry<Integer, Integer> entry:listOfentrySet)
     System.out.print(entry.getKey()+"="+entry.getValue()+"  ");


   }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.LinkedHashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.Set；
类SortByKeyComparator{
@凌驾
公共int比较（Map.Entry条目1，Map.Entry条目2）{
return（entry1.getKey（））.compareTo（entry2.getKey（））；
}
}
公共类SortMapByKeyAscendingExample{
公共静态void main（字符串…a）{
Map Map=newlinkedhashmap（）；
地图.put（4,1）；
地图.put（2,1）；
地图.put（3,1）；
地图.put（5,1）；
Set entrySet=map.entrySet（）；
List listOfentrySet=新的ArrayList（entrySet）；
System.out.print（“按键排序前：”）；
for（Map.Entry:listOfentrySet）{
System.out.print（entry.getKey（）+“=”+entry.getValue（）+”）；
}
排序（listOfentrySet，new SortByKeyAscending（））；
系统输出打印（“\n按键排序后（升序）：”；
for（Map.Entry:listOfentrySet）
System.out.print（entry.getKey（）+“=”+entry.getValue（）+”）；
}
}

输出将是（键值）

排序前：4=12=13=15=1

---

排序后：2=13=14=15=1实现Comparator接口并在java中重写其比较方法。 获取集合中的map.entrySet（），将其转换为list（我们已将集合转换为list，因为集合的排序方法只能接受list类型作为参数）。 调用Collections.sort和pass list[即listOfentrySet]作为参数。 Collections.sort在内部调用Arrays.sort，Arrays.sort（）在内部调用Merge-sort。Merge-sort调用Comparator接口的compare方法来比较键。最终，listOfentrySet将包含基于java键排序的条目（键值）对

这是一个简单的谷歌搜索，但您可以：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;



class SortByKeyAscending implements Comparator<Map.Entry<Integer, Integer>>{

@Override
public int compare( Map.Entry<Integer,Integer> entry1, Map.Entry<Integer,Integer> entry2){
    return (entry1.getKey()).compareTo( entry2.getKey() );
    }
}



public class SortMapByKeyAscendingExample {

public static void main(String...a){
    Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
    map.put(4, 1);
    map.put(2, 1);
    map.put(3, 1);
    map.put(5, 1);

    Set<Entry<Integer, Integer>> entrySet = map.entrySet();
    List<Entry<Integer, Integer>> listOfentrySet = new ArrayList<Entry<Integer, Integer>>(entrySet);

    System.out.print("Before sorting by key : ");
    for(Map.Entry<Integer, Integer> entry:listOfentrySet){
     System.out.print(entry.getKey()+"="+entry.getValue()+"  ");
    }

    Collections.sort(listOfentrySet, new SortByKeyAscending());


    System.out.print("\nAfter sorting by key(ascending): ");
    for(Map.Entry<Integer, Integer> entry:listOfentrySet)
     System.out.print(entry.getKey()+"="+entry.getValue()+"  ");


   }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.LinkedHashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.Set；
类SortByKeyComparator{
@凌驾
公共int比较（Map.Entry条目1，Map.Entry条目2）{
return（entry1.getKey（））.compareTo（entry2.getKey（））；
}
}
公共类SortMapByKeyAscendingExample{
公共静态void main（字符串…a）{
Map Map=newlinkedhashmap（）；
地图.put（4,1）；
地图.put（2,1）；
地图.put（3,1）；
地图.put（5,1）；
Set entrySet=map.entrySet（）；
List listOfentrySet=新的ArrayList（entrySet）；
System.out.print（“按键排序前：”）；
for（Map.Entry:listOfentrySet）{
System.out.print（entry.getKey（）+“=”+entry.getValue（）+”）；
}
排序（listOfentrySet，new SortByKeyAscending（））；
系统输出打印（“\n按键排序后（升序）：”；
for（Map.Entry:listOfentrySet）
System.out.print（entry.getKey（）+“=”+entry.getValue（）+”）；
}
}

输出将是（键值）

排序前：4=12=13=15=1

---

排序后：2=1 3=1 4=1 5=1

如果我正确理解了您的要求，因为树映射本身无法对您想要的值进行排序，如下所示：

List<String> wordsList = new ArrayList<String>();
map.forEach((k, v) -> wordsList.add(k));
System.out.println(Arrays.toString(wordsList.toArray()));

或者这个：

List<String> wordsList = new ArrayList<String>();
for(Map.Entry<String, Integer> entry : map.entrySet()) {
  String key = entry.getKey();
  for(int i = 0 ; i <= entry.getValue(); i++) {
    wordsList.add(key);
  } 
}
System.out.println(Arrays.toString(wordsList.toArray()));

---

如果我正确理解了您的需求，因为树映射本身不能对您想要的值进行排序，如下所示：

List<String> wordsList = new ArrayList<String>();
map.forEach((k, v) -> wordsList.add(k));
System.out.println(Arrays.toString(wordsList.toArray()));

或者这个：

List<String> wordsList = new ArrayList<String>();
for(Map.Entry<String, Integer> entry : map.entrySet()) {
  String key = entry.getKey();
  for(int i = 0 ; i <= entry.getValue(); i++) {
    wordsList.add(key);
  } 
}
System.out.println(Arrays.toString(wordsList.toArray()));

---

如果要按计数顺序打印结果，可以执行以下操作：

map.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue())
        .forEach(e -> System.out.println(e.getKey() + "\t" + e.getValue()));

您还可以首先使用streams生成频率图：

Pattern.compile("[\\s+\\p{P}]")
        .splitAsStream(text)
        .map(String::toLowerCase)
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
        .entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue())
        .forEach(e -> System.out.println(e.getKey() + "\t" + e.getValue()));

---

如果要按计数顺序打印结果，可以执行以下操作：

map.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue())
        .forEach(e -> System.out.println(e.getKey() + "\t" + e.getValue()));

您还可以首先使用streams生成频率图：

Pattern.compile("[\\s+\\p{P}]")
        .splitAsStream(text)
        .map(String::toLowerCase)
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
        .entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue())
        .forEach(e -> System.out.println(e.getKey() + "\t" + e.getValue()));

---

预期输入/输出？按什么排序？这个词？你的代码已经这样做了。预期的输入/输出？按什么排序？这个词？你的代码已经这样做了。OP对单词排序的要求不明确，但如果我错了，请纠正我，他不是说他希望输出作为列表吗？@shash678如果是，他没有尝试这样做。我的解释是，他想把它们打印成一个列表。OP对他想让单词按什么排序是模棱两可的，但如果我错了，请纠正我，他不是说他想把输出作为一个列表吗？@shash678如果是，他没有尝试这样做。我的解释是，他想把它们打印成一个列表。