CSV文件中的Java排序依据2参数

电流输出： 仅按最高分数排序

我如何使它能够按最高分数排序，然后按最低尝试排序？示例xxxxx，6,1，xxxx，6,1 xxxx，6,4

救命啊！！！！！！被困了几个小时

public static void sort() {
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader("data.csv"));
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    Map < String, List < String >> map = new TreeMap < String, List < String >> ();
    String line;
    try {
        line = reader.readLine();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } //read header
    try {
        while ((line = reader.readLine()) != null) {
            String key = getField(line);

            List < String > l = map.get(key);

            if (l == null) {
                l = new LinkedList < String > ();
                map.put(key, l);
            }
            l.add(line);
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    try {
        reader.close();
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    System.out.println("HALL OF FAME\nMatric, Marks, Attempt");
    map = ((TreeMap < String, List < String >> ) map).descendingMap();

    for (List < String > list: map.values()) {
        for (String val: list) {
            System.out.println(val);
        }
    }
}


private static String getField(String line) {
    return line.split(",")[1]; // extract value you want to sort on
}

publicstaticvoidsort（）{
BufferedReader reader=null；
试一试{
reader=新的BufferedReader（新的文件阅读器（“data.csv”）；
}catch（filenotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
Map>Map=newtreemap>（）；
弦线；
试一试{
line=reader.readLine（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}//读取标题
试一试{
而（（line=reader.readLine（））！=null）{
字符串键=getField（行）；
Listl=map.get（键）；
if（l==null）{
l=新链接列表（）；
地图放置（键，l）；
}
l、 添加（行）；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
reader.close（）；
}捕获（IOE1异常）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
System.out.println（“名人堂\n地图、标记、尝试”）；
map=（（TreeMap）map）；
对于（ListList:map.values（））{
for（字符串val:list）{
系统输出打印项次（val）；
}
}
}
私有静态字符串getField（字符串行）{
返回行。拆分（“，”[1]；//提取要排序的值
}

它似乎起作用了

public static void sort() throws FileNotFoundException {
    BufferedReader reader;
    try {
        reader = new BufferedReader(new FileReader("data.csv"));
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        throw e;
    }
    Map<MarkAndAttempt, List<String>> map =
            new TreeMap<MarkAndAttempt, List<String>>(new Comparator<MarkAndAttempt>() {
                @Override
                public int compare(MarkAndAttempt o1, MarkAndAttempt o2) {
                    if (o1.getMark() > o2.getMark()) {
                        return -1;
                    } else if (o1.getMark() == o2.getMark()) {
                        return o1.getAttempt() > o2.getAttempt() ? 1 : -1;
                    } else {
                        return 1;
                    }
                }
            });
    String line;
    try {
        reader.readLine();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }//read header
    try {
        while ((line = reader.readLine()) != null) {
            //String key = getField(line);

            //List<String> l = map.get(key);

            MarkAndAttempt markAndAttempt = generateMarkAndAttempt(line);
            List<String> l = map.get(markAndAttempt);

            if (l == null) {
                l = new LinkedList<String>();
                map.put(markAndAttempt, l);
            }
            l.add(line);
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    try {
        reader.close();
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    System.out.println("HALL OF FAME\nMatric, Marks, Attempt");

    for (List<String> list : map.values()) {
        for (String val : list) {
            System.out.println(val);
        }



    }
}


private static MarkAndAttempt generateMarkAndAttempt(String line) {
    Objects.requireNonNull(line);
    String[] parts = line.split(",");
    if (parts.length != 3) throw new IllegalArgumentException("");
    return new MarkAndAttempt(Integer.valueOf(parts[1].trim()), Integer.valueOf(parts[2].trim()));
}

private static String getField(String line) {
    return line.split(",")[1];// extract value you want to sort on
}

static class MarkAndAttempt {

    private int mark;

    private int attempt;

    public MarkAndAttempt(int mark, int attempt) {
        this.mark = mark;
        this.attempt = attempt;
    }

    public int getMark() {
        return mark;
    }

    public void setMark(int mark) {
        this.mark = mark;
    }

    public int getAttempt() {
        return attempt;
    }

    public void setAttempt(int attempt) {
        this.attempt = attempt;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        MarkAndAttempt that = (MarkAndAttempt) o;

        return mark == that.mark;

    }

    @Override
    public int hashCode() {
        return mark;
    }
}

publicstaticvoidsort（）抛出FileNotFoundException{
缓冲读取器；
试一试{
reader=新的BufferedReader（新的文件阅读器（“data.csv”）；
}catch（filenotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
投掷e；
}
地图=
新树映射（新比较器（）{
@凌驾
公共整数比较（MarkAndAttempt o1，MarkAndAttempt o2）{
如果（o1.getMark（）>o2.getMark（））{
返回-1；
}否则如果（o1.getMark（）==o2.getMark（））{
返回o1.gettrunt（）>o2.gettrunt（）？1:-1；
}否则{
返回1；
}
}
});
弦线；
试一试{
reader.readLine（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}//读标题
试一试{
而（（line=reader.readLine（））！=null）{
//字符串键=getField（行）；
//列表l=map.get（键）；
MarkAndAttempt MarkAndAttempt=生成MarkAndAttempt（行）；
列表l=map.get（markAndAttempt）；
if（l==null）{
l=新链接列表（）；
地图放置（标记和尝试，l）；
}
l、 添加（行）；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
reader.close（）；
}捕获（IOE1异常）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
System.out.println（“名人堂\n地图、标记、尝试”）；
对于（列表：map.values（））{
for（字符串val:list）{
系统输出打印项次（val）；
}
}
}
专用静态标记和尝试生成器标记和尝试（字符串行）{
对象。requirennull（行）；
String[]parts=line.split（“，”）；
如果（parts.length！=3）抛出新的IllegalArgumentException（“”）；
返回新的MarkAndAttempt（Integer.valueOf（parts[1].trim（）），Integer.valueOf（parts[2].trim（））；
}
私有静态字符串getField（字符串行）{
返回行。拆分（“，”[1]；//提取要排序的值
}
静态类标记和尝试{
私有整数标记；
私人企图；
公共标记和尝试（整数标记，整数尝试）{
这个。马克=马克；
这个。尝试=尝试；
}
公共int getMark（）{
返回标记；
}
公共无效设置标记（整数标记）{
这个。马克=马克；
}
公共int gettrunt（）{
回击尝试；
}
公共无效设置尝试（int尝试）{
这个。尝试=尝试；
}
@凌驾
公共布尔等于（对象o）{
如果（this==o）返回true；
如果（o==null | | getClass（）！=o.getClass（））返回false；
MarkAndAttempt that=（MarkAndAttempt）o；
return mark==that.mark；
}
@凌驾
公共int hashCode（）{
返回标记；
}
}

为什么要显示屏幕截图？只需将你的输出粘贴到问题中。不要发布应该包含在文章中的数据链接。一旦你提供的链接失效（而且肯定会失效），你希望你的问题如何帮助他人？这一行有多个标记。无法将比较器解析为类型。构造函数树映射。。。。未定义。方法比较（main…）必须重写或实现超级方法。。googlingimport比较器*。现在做源csv文件格式不喜欢下划线：

A，2,2 B，3,1 C，2,1 A，2,3 B，1,0 D，2,2

结果仍然是一样的：（.-我导入了构造函数和对象。有什么问题吗？既然你的可以工作