list对象集合按照对象的某个值排序
 
对象需要继承 Comparable
 
@Data
public class TeamPerformance implements  Comparable<TeamPerformance>,Serializable{
    private static final long serialVersionUID = -6728798297301322140L;
    /**
     * 战队id
     */
    private Integer tId;
    /**
     * 战队总业绩
     */
    private BigDecimal tMoney;


    /**
     * 战队总业绩
     */
    private int tGold;

    /**
     * 战队名字
     */
    private String tName;

    /**
     * 按照tMoney排序 如果tMoney一样 按照id排序
     * @param o
     * @return
     * -表示从大到小排序 去掉则表示从小到大排序
     */
    @Override
    public int compareTo(TeamPerformance o) {
        // 先比较销售业绩 按照销售业绩降序排列
        int i=-this.getTMoney().compareTo(o.getTMoney());
        // 如果销售业绩相同 按照金币 降序排列
        if(i==0){
            return  -this.getTGold()-o.getTGold();
        }
        // 如果金币和销售业绩相同 按照战队id 排列
        if(i==0&&(this.getTGold()-this.getTGold()==0)){
            return  -this.getTId() - o.getTId();
        }
        return i;
    }
}
 
排序
 
	 @Test
    public void testTeamPerformance(){
      List<TeamPerformance> list=new ArrayList<>();
      list.add(new TeamPerformance(2,new BigDecimal(20),"王子"));
      list.add(new TeamPerformance(3,new BigDecimal(30),"王子王"));
      list.add(new TeamPerformance(4,new BigDecimal(40),"王子王子"));
      list.add(new TeamPerformance(1,new BigDecimal(10),"王"));
      list.add(new TeamPerformance(5,new BigDecimal(50),"王子王子王"));
        Collections.sort(list);
        for (TeamPerformance teamPerformance : list) {
                   System.out.println(teamPerformance);
                  }
    }

例子：Java中对list map根据map某个key值进行排序的方法
 
List<Map<String, Object>> productAttributeColors = new ArrayList<>();

//productAttributeColors 按 position 重新排序 start
Collections.sort(productAttributeColors, new Comparator<Map<String, Object>>() {
    public int compare(Map<String, Object> map1, Map<String, Object> map2) {
    Integer position1 = Integer.valueOf(map1.get("position").toString()) ;
    Integer position2 = Integer.valueOf(map2.get("position").toString()) ;
    return position1.compareTo(position2);
    }
});
//productAttributeColors 按 position 重新排序 end
 
 
 
 
 

按照A对象中的orderIndex的值进行排序
private List<A> sortlist(List<A> list) {
    Collections.sort(list, new Comparator<A>() {
        @Override
        public int compare(A o1, A o2) {
            //按照值的大小进行升序排序
            return o1.getOrderIndex() - o2.getOrderIndex();
        }
    });
    return list;
}

Collections.sort(list, new Comparator<String>(){
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }});
 
释：o1,o2,即为list里面的对象；list为集合，按照对象的length长度升序排序（反过来降序），如果为复杂对象，length可以换成对象里具体字段。例如：员工对象，按照工资排序。如下：
 
Collections.sort(list, new Comparator<Emp >(){
public int compare(Emp o1, Emp o2) {
                    return o1.getSalary()-o2.getSalary(); 
                 }});
 
转载自https://blog.csdn.net/halfgap/article/details/81710709?utm_source=blogxgwz9