Java 我们可以在地图中按键和值对集合进行排序吗？

我有一辆代表汽车名称和ID的汽车：

public class Car {
String name;
int ID;
}

另一类代表比赛，我需要按照比赛顺序对汽车进行分类：

public class Race {
private Set<Car> cars = new TreeSet<>();
private Map<Integer, Integer> races = new TreeMap<>();//key represents the order in race, value represents the ID of a car, so i need to sort cars by the keys in races
...
public Collection getSortedCars() { ??? }
}

公共级比赛{
私家车=新树集（）；
private Map races=new TreeMap（）；//key表示比赛中的顺序，value表示汽车的ID，因此我需要根据比赛中的键对汽车进行排序
...
公共集合getSortedCars（）{？？？}
}

-有没有办法把车分类？多谢

编辑：很抱歉，我使用了非常糟糕的值示例，因此这里是标识符示例，我希望您得到我需要的。

我甚至不会对SortedSet执行此操作。原因是种族可以被修改，从而使树集中的任何结构失效，从而使行为“不可预测”

相反，我会让

getSortedCars

首先从集合中获取序列（例如列表），然后排序并返回这样的序列

实际的排序是“琐碎的”和自定义的，因为这实际上是一个“排序依据”操作，例如：

class CompareCarsByWins implements Comparator<Car> {
    Map<Car,Integer> wins;

    public CompareCarsByWins(Map<Car,Integer> wins) {
        this.wins = wins;
    }

    public int compareTo (Car a, Car b) {
        // Actual code should handle "not found" cars as appropriate
        int winsA = wins.get(a);
        int winsB = wins.get(b);
        if (winsA == winsB) {
            // Tie, uhm, let's .. choose by name
            return a.getName().compareTo(b.getName());
        } else {
            // Sort most wins first
            return winsB - winsA;
        }
    }
    // ..
}

// Usage:
List<Car> results = new ArrayList<Car>(cars);
Collections.sort(results, new CompareCarsByWins(races));

类CompareCarsByWins实现Comparator{
地图获胜；
公共比较CARSBYWINS（地图wins）{
this.wins=wins；
}
公共内部比较（a车、b车）{
//实际代码应酌情处理“未找到”的车辆
int winsA=wins.get（a）；
int winsB=wins.get（b）；
if（winsA==winsB）{
//领带，嗯，让我们…按名字选择
返回a.getName（）.compareTo（b.getName（））；
}否则{
//首先对大多数赢家进行排序
返回winsB-winsA；
}
}
// ..
}
//用法：
列表结果=新阵列列表（cars）；
排序（结果，新的CompareCarsByWins（种族））；

我甚至不会用SortedSet做这件事。原因是种族可以被修改，从而使树集中的任何结构失效，从而使行为“不可预测”

相反，我会让

getSortedCars

首先从集合中获取序列（例如列表），然后排序并返回这样的序列

实际的排序是“琐碎的”和自定义的，因为这实际上是一个“排序依据”操作，例如：

class CompareCarsByWins implements Comparator<Car> {
    Map<Car,Integer> wins;

    public CompareCarsByWins(Map<Car,Integer> wins) {
        this.wins = wins;
    }

    public int compareTo (Car a, Car b) {
        // Actual code should handle "not found" cars as appropriate
        int winsA = wins.get(a);
        int winsB = wins.get(b);
        if (winsA == winsB) {
            // Tie, uhm, let's .. choose by name
            return a.getName().compareTo(b.getName());
        } else {
            // Sort most wins first
            return winsB - winsA;
        }
    }
    // ..
}

// Usage:
List<Car> results = new ArrayList<Car>(cars);
Collections.sort(results, new CompareCarsByWins(races));

类CompareCarsByWins实现Comparator{
地图获胜；
公共比较CARSBYWINS（地图wins）{
this.wins=wins；
}
公共内部比较（a车、b车）{
//实际代码应酌情处理“未找到”的车辆
int winsA=wins.get（a）；
int winsB=wins.get（b）；
if（winsA==winsB）{
//领带，嗯，让我们…按名字选择
返回a.getName（）.compareTo（b.getName（））；
}否则{
//首先对大多数赢家进行排序
返回winsB-winsA；
}
}
// ..
}
//用法：
列表结果=新阵列列表（cars）；
排序（结果，新的CompareCarsByWins（种族））；

我甚至不会用SortedSet做这件事。原因是种族可以被修改，从而使树集中的任何结构失效，从而使行为“不可预测”

相反，我会让

getSortedCars

首先从集合中获取序列（例如列表），然后排序并返回这样的序列

实际的排序是“琐碎的”和自定义的，因为这实际上是一个“排序依据”操作，例如：

class CompareCarsByWins implements Comparator<Car> {
    Map<Car,Integer> wins;

    public CompareCarsByWins(Map<Car,Integer> wins) {
        this.wins = wins;
    }

    public int compareTo (Car a, Car b) {
        // Actual code should handle "not found" cars as appropriate
        int winsA = wins.get(a);
        int winsB = wins.get(b);
        if (winsA == winsB) {
            // Tie, uhm, let's .. choose by name
            return a.getName().compareTo(b.getName());
        } else {
            // Sort most wins first
            return winsB - winsA;
        }
    }
    // ..
}

// Usage:
List<Car> results = new ArrayList<Car>(cars);
Collections.sort(results, new CompareCarsByWins(races));

类CompareCarsByWins实现Comparator{
地图获胜；
公共比较CARSBYWINS（地图wins）{
this.wins=wins；
}
公共内部比较（a车、b车）{
//实际代码应酌情处理“未找到”的车辆
int winsA=wins.get（a）；
int winsB=wins.get（b）；
if（winsA==winsB）{
//领带，嗯，让我们…按名字选择
返回a.getName（）.compareTo（b.getName（））；
}否则{
//首先对大多数赢家进行排序
返回winsB-winsA；
}
}
// ..
}
//用法：
列表结果=新阵列列表（cars）；
排序（结果，新的CompareCarsByWins（种族））；

我甚至不会用SortedSet做这件事。原因是种族可以被修改，从而使树集中的任何结构失效，从而使行为“不可预测”

相反，我会让

getSortedCars

首先从集合中获取序列（例如列表），然后排序并返回这样的序列

实际的排序是“琐碎的”和自定义的，因为这实际上是一个“排序依据”操作，例如：

class CompareCarsByWins implements Comparator<Car> {
    Map<Car,Integer> wins;

    public CompareCarsByWins(Map<Car,Integer> wins) {
        this.wins = wins;
    }

    public int compareTo (Car a, Car b) {
        // Actual code should handle "not found" cars as appropriate
        int winsA = wins.get(a);
        int winsB = wins.get(b);
        if (winsA == winsB) {
            // Tie, uhm, let's .. choose by name
            return a.getName().compareTo(b.getName());
        } else {
            // Sort most wins first
            return winsB - winsA;
        }
    }
    // ..
}

// Usage:
List<Car> results = new ArrayList<Car>(cars);
Collections.sort(results, new CompareCarsByWins(races));

类CompareCarsByWins实现Comparator{
地图获胜；
公共比较CARSBYWINS（地图wins）{
this.wins=wins；
}
公共内部比较（a车、b车）{
//实际代码应酌情处理“未找到”的车辆
int winsA=wins.get（a）；
int winsB=wins.get（b）；
if（winsA==winsB）{
//领带，嗯，让我们…按名字选择
返回a.getName（）.compareTo（b.getName（））；
}否则{
//首先对大多数赢家进行排序
返回winsB-winsA；
}
}
// ..
}
//用法：
列表结果=新阵列列表（cars）；
排序（结果，新的CompareCarsByWins（种族））；

不清楚地图中整数的含义，或者它们与汽车记录的关系。如果您希望在创建一组对象之后对其进行排序，则可以创建一个新的树集，其中包含一个显式比较器，该比较器使用比赛数据对单个汽车记录进行排序。目前尚不清楚地图中整数的含义，或它们与汽车记录的关系。如果您希望在创建一组对象之后对其进行排序，则可以创建一个新的树集，其中包含一个显式比较器，该比较器使用比赛数据对单个汽车记录进行排序。目前尚不清楚地图中整数的含义，或它们与汽车记录的关系。如果您希望在创建一组对象之后对其进行排序，则可以使用显式比较器创建一个新的树集，该比较器使用比赛数据对单个汽车记录进行排序。