【无标题】

给定一些同学的信息（名字，成绩）序列，请你将他们的信息按照成绩从高到低或从低到高的排列,相同成绩

都按先录入排列在前的规则处理。

例示：
jack      70
peter     96
Tom       70
smith     67

从高到低  成绩
peter     96
jack      70
Tom       70
smith     67

从低到高

smith     67

jack      70

Tom       70

peter     96

注：0代表从高到低，1代表从低到高

输入描述：

第一行输入要排序的人的个数n，第二行输入一个整数表示排序的方式，之后n行分别输入他们的名字和成绩，以一个空格隔开

输出描述：

按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开

输入：

3
0
fang 90
yang 50
ning 70

输出：

fang 90
ning 70
yang 50

解题思路：

本想着用linkedHashMap直接排序解，结果这里面有同名不同分的。这样会覆盖掉之前同key的value值。。。。。

还是贴上吧，无论如何加强了hashMap排序的写法

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int reverse = in.nextInt();
        
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i <= n; i++) {
            String t = in.nextLine();
            if(t.length() == 0) continue;
            String[] name = t.split(" ");
            // System.out.println(t);
            String name1 = name[0];
            String grade = name[1];
            map.put(name1, Integer.valueOf(grade));
        }
        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet());
        for (Map.Entry<String, Integer> s : entryList) {
            System.out.println(s.getKey() + " " + s.getValue());
        }
        // System.out.print(entryList.size());
        if (reverse == 0) {
            Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
                public int compare(Map.Entry<String, Integer> s1,
                                   Map.Entry<String, Integer>s2) {
                    int g1 = s1.getValue(), g2 = s2.getValue();
                    return g2 - g1;
                }
            });
        } else {
            Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
                public int compare(Map.Entry<String, Integer> s1,
                                   Map.Entry<String, Integer>s2) {
                    int g1 = s1.getValue(), g2 = s2.getValue();
                    return g1 - g2;
                }
            });
        }
        // for (Map.Entry<String, Integer> s : entryList) {
        //     System.out.println(s.getKey() + " " + s.getValue());
        // }
    }
}

正确做法：

• 通过一个二维数组，每一行包括姓名编号，成绩，将输入的姓名用编号代替，第二列保存成绩
• 自定义排序
  • 倒序，按第二列的成绩降序排列,如果相等的话，返回0，顺序不变，因为默认编号是升序的，符合题意
  • 升序则 按成绩升序排序
• 最后根据已经排序后的数组，顺序输出结果

import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        HashMap<Integer,String> map = new HashMap<>();
        while(sc.hasNextLine()){
            // 学生成绩数
            int n = Integer.parseInt(sc.nextLine());
            //1是升序，0是降序
            int flag = Integer.parseInt(sc.nextLine());
            // 每一行包括姓名编号，成绩
            int[][] score = new int[n][2];
            for(int i=0;i<n;i++){
                String[] nameAndScore = sc.nextLine().split(" ");
                // 学生用编号代替
                score[i][0] = i;
                score[i][1] = Integer.parseInt(nameAndScore[1]);
                map.put(i,nameAndScore[0]);
            }
            // 自定义排序
            Arrays.sort(score,(o1,o2) ->{
                // 倒序，按第二列的成绩降序排列,如果相等的话，返回0，顺序不变，因为默认编号是升序的，符合题意
                if(flag==0){
                    return o2[1] - o1[1];
                }else{
                    // 按成绩升序排序
                    return o1[1] - o2[1];
                }
            });
            // 根据已经排序后的数组，顺序输出结果
            for(int i=0;i<n;i++){
                System.out.println(map.get(score[i][0]) + " " + score[i][1]);
            }
        }
    }
}

java中的linkedHashMap的lambda形式的排序如下：

LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
map.put(1, "apple");
map.put(2, "banana");
map.put(3, "orange");

// 使用lambda表达式对LinkedHashMap进行倒序排序
LinkedHashMap<Integer, String> reversedMap = map.entrySet()
    .stream()
    .sorted(Map.Entry.<Integer, String>comparingByKey().reversed())
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                              (oldValue, newValue) -> oldValue, LinkedHashMap::new));

// 输出倒序排列后的LinkedHashMap
System.out.println(reversedMap);

在上面的示例代码中，.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new))这一行代码用于将流中的元素收集到一个新的LinkedHashMap对象中。

该方法有四个参数，分别为：

1. Map.Entry::getKey：指定用于生成新Map的键值的提取函数，这里使用了Java 8中的方法引用来获取键值。
2. Map.Entry::getValue：指定用于生成新Map的键值的提取函数，同样使用方法引用来获取键值。
3. (oldValue, newValue) -> oldValue：指定用于解决键冲突的合并函数，这里我们简单地返回旧值，表示当发生键冲突时保留旧值。
4. LinkedHashMap::new：指定用于生成新Map的构造函数，这里使用了LinkedHashMap的无参构造函数。

这里的(oldValue, newValue) -> oldValue是一个Lambda表达式，其参数oldValue和newValue分别表示相同键的旧值和新值。在这里，我们简单地返回了旧值，即oldValue，这意味着当相同的键值出现时，我们将保留旧值，而不是使用新值。