Java 按值对映射排序，然后按键中的属性排序？

我有一个

映射

，其中

整数

是一个权重。每个用户都有一个id。我想返回一个

列表

，其中用户首先按权重排序，但如果权重相等，我希望他们按用户id排序。我提出了一个方法，但我认为我缺少了一些东西，因为我认为应该更简单。。有人能帮我吗？我目前的做法如下

注意：我正在使用Java6

public List<User> sortUsers(Map<User, Integer> userWeightMap) {
  SortedSet<Map.Entry<CustomObject, Integer>> sortedSet = new TreeSet<Map.Entry<CustomObject, Integer>>(new Comparator<Map.Entry<CustomObject, Integer>>() {
      @Override
      public int compare(Map.Entry<CustomObject, Integer> e1, Map.Entry<CustomObject, Integer> e2) {
          if (e1.getValue() == e2.getValue()) {
              // Weights are equal, sort by id instead
              if (e1.getKey().getUser().getId() > e2.getKey().getUser().getId()) {
                  return 1;
              } else {
                  return -1;
              }
          } else {
              return e1.getValue().compareTo(e2.getValue());
          }
      }
  });
  sortedSet.addAll(userWeightMap.entrySet());

  ArrayList<CustomObject> userSortedByWeightThenId = new ArrayList<CustomObject>();
  for (Map.Entry<CustomObject, Integer> bestiltDelstrekningIntegerEntry : sortedSet) {
      userSortedByWeightThenId.add(bestiltDelstrekningIntegerEntry.getKey());
  }
  return userSortedByWeightThenId;
}

公共列表排序器（Map userWeightMap）{
SortedSet SortedSet=新树集（新比较器（）{
@凌驾
公共整数比较（Map.Entry e1，Map.Entry e2）{
如果（e1.getValue（）==e2.getValue（））{
//权重相等，改为按id排序
如果（e1.getKey（）.getUser（）.getId（）>e2.getKey（）.getUser（）.getId（））{
返回1；
}否则{
返回-1；
}
}否则{
返回e1.getValue（）.compareTo（e2.getValue（））；
}
}
});
sortedSet.addAll（userWeightMap.entrySet（））；
ArrayList userSortedByWeightThenId=new ArrayList（）；
用于（地图条目BestFiltDelstreKningIntegerEntry:sortedSet）{
userSortedByWeightThenId.add（bestiltdelstreckningintegerentry.getKey（））；
}
返回userSortedByWeightThenId；
}

当您解释您的情况时，您必须像这样维护方法签名

public List sortuser（Map userWeightMap）

然后我发现你的方法是好的。我重构了您的代码，并尝试了以下方法

public static List<User> sortUsers(Map<User, Integer> userMap) {

        Comparator<Map.Entry<User, Integer>> comparator = new Comparator<Map.Entry<User, Integer>>() {
            @Override
            public int compare(Map.Entry<User, Integer> e1, Map.Entry<User, Integer> e2) {

                if(e1.getValue().equals(e2.getValue())){
                    return e1.getKey().getId() > e2.getKey().getId() ? 1 : -1;
                }

                return e1.getValue().compareTo(e2.getValue());
            }
        };

        List<Map.Entry<User, Integer>> list = new ArrayList<Map.Entry<User, Integer>>(userMap.entrySet());

        Collections.sort(list, comparator);

        List<User> sortedList = new LinkedList<>();
        for(Map.Entry<User, Integer> entry : list) {
            sortedList.add(entry.getKey());
        }

        return sortedList;
    }

公共静态列表排序器（Map userMap）{
比较器比较器=新比较器（）{
@凌驾
公共整数比较（Map.Entry e1，Map.Entry e2）{
如果（e1.getValue（）.equals（e2.getValue（）））{
返回e1.getKey（）.getId（）>e2.getKey（）.getId（）？1:-1；
}
返回e1.getValue（）.compareTo（e2.getValue（））；
}
};
List List=newarraylist（userMap.entrySet（））；
集合。排序（列表、比较）；
List sortedList=新建LinkedList（）；
用于（映射条目：列表）{
sortedList.add（entry.getKey（））；
}
返回分类列表；
}

这里我使用了

Collections.sort（）

util函数。因为此方法将

列表

作为参数。我更喜欢使用

地图的
列表
。用户地图的
条目
。然后简单地使用比较器对列表进行排序
LinkedList
用于确保插入顺序，从而确保排序

注意：目前我无法检查该代码的JavaSE6语法。但我希望这没有问题
 当您解释您的情况时，您必须像这样维护方法签名

public List sortuser（Map userWeightMap）

然后我发现你的方法是好的。我重构了您的代码，并尝试了以下方法

public static List<User> sortUsers(Map<User, Integer> userMap) {

        Comparator<Map.Entry<User, Integer>> comparator = new Comparator<Map.Entry<User, Integer>>() {
            @Override
            public int compare(Map.Entry<User, Integer> e1, Map.Entry<User, Integer> e2) {

                if(e1.getValue().equals(e2.getValue())){
                    return e1.getKey().getId() > e2.getKey().getId() ? 1 : -1;
                }

                return e1.getValue().compareTo(e2.getValue());
            }
        };

        List<Map.Entry<User, Integer>> list = new ArrayList<Map.Entry<User, Integer>>(userMap.entrySet());

        Collections.sort(list, comparator);

        List<User> sortedList = new LinkedList<>();
        for(Map.Entry<User, Integer> entry : list) {
            sortedList.add(entry.getKey());
        }

        return sortedList;
    }

公共静态列表排序器（Map userMap）{
比较器比较器=新比较器（）{
@凌驾
公共整数比较（Map.Entry e1，Map.Entry e2）{
如果（e1.getValue（）.equals（e2.getValue（）））{
返回e1.getKey（）.getId（）>e2.getKey（）.getId（）？1:-1；
}
返回e1.getValue（）.compareTo（e2.getValue（））；
}
};
List List=newarraylist（userMap.entrySet（））；
集合。排序（列表、比较）；
List sortedList=新建LinkedList（）；
用于（映射条目：列表）{
sortedList.add（entry.getKey（））；
}
返回分类列表；
}

这里我使用了
Collections.sort（）
util函数。因为此方法将
列表
作为参数。我更喜欢使用
地图的
列表
。用户地图的
条目
。然后简单地使用比较器对列表进行排序
LinkedList
用于确保插入顺序，从而确保排序

注意：目前我无法检查该代码的JavaSE6语法。但我希望这没有问题
 我不确定您的
CustomObject
有什么好处

您不应该重复添加到像TreeSet这样的SortedSet，因为每次添加都会重新排列顺序，因此会浪费性能。
相反，您应该在一次运行中对最终列表进行排序

例如，像这样：

public List<User> sort(final Map<User, Integer> userToWeight) {
    Comparator<User> primaryWeightSecondaryId = new Comparator<User>() {
        @Override
        public int compare(User left, User right) {
            Integer leftWeight = userToWeight.get(left);
            Integer rightWeight = userToWeight.get(right);
            int primary = leftWeight.compareTo(rightWeight);
            if (primary != 0) {
                return primary;
            }
            // secondary
            return Integer.valueOf(left.getId()).compareTo(right.getId());
        }
    };

    List<User> users = new ArrayList<User>(userToWeight.keySet());
    Collections.sort(users, primaryWeightSecondaryId);
    return users;
}

公共列表排序（最终映射用户权限）{
Comparator primaryWeightSecondaryId=新比较器（）{
@凌驾
公共整数比较（用户左、用户右）{
整数leftWeight=userToWeight.get（左）；
整数rightWeight=userToWeight.get（右）；
int primary=leftWeight.compareTo（rightwweight）；
如果（主！=0）{
返回主；
}
//次要的
返回Integer.valueOf（left.getId（））.compareTo（right.getId（））；
}
};
List users=newarraylist（usertowight.keySet（））；
Collections.sort（用户，primaryWeightSecondaryId）；
返回用户；
}
我不确定您的
CustomObject
有什么用

您不应该重复添加到像TreeSet这样的SortedSet，因为每次添加都会重新排列顺序，因此会浪费性能。
相反，您应该在一次运行中对最终列表进行排序

例如，像这样：

public List<User> sort(final Map<User, Integer> userToWeight) {
    Comparator<User> primaryWeightSecondaryId = new Comparator<User>() {
        @Override
        public int compare(User left, User right) {
            Integer leftWeight = userToWeight.get(left);
            Integer rightWeight = userToWeight.get(right);
            int primary = leftWeight.compareTo(rightWeight);
            if (primary != 0) {
                return primary;
            }
            // secondary
            return Integer.valueOf(left.getId()).compareTo(right.getId());
        }
    };

    List<User> users = new ArrayList<User>(userToWeight.keySet());
    Collections.sort(users, primaryWeightSecondaryId);
    return users;
}

公共列表排序（最终映射用户权限）{
Comparator primaryWeightSecondaryId=新比较器（）{
@凌驾
公共整数比较（用户左、用户右）{
整数leftWeight=userToWeight.get（左）；
整数rightWeight=userToWeight.get（右）；
int primary=leftWeight.compareTo（rightwweight）；
如果（主！=0）{
返回主；
}
//次要的
返回Integer.valueOf（left.getId（））.compareTo（right.getI