java排序算法----排序

两个list
1 用户list（size未知）
id name

001 张三
002 李四
003 王五

2 投标金额list （size未知）
用户id 积分
001 100
001 80
002 90
003 60
002 30

需要结果，根据用户投标金额从小到大进行排名，（李四报价最低30，所以为第一，王五的最低价为60，所以是第二，以此类推）

李四   排名 1
王五   排名 2
张三   排名 3

```Map<String,Object> map = new HashMap<>();
        map.put("001","张三");
        map.put("002","李四");
        map.put("003","王五");
        List<MyMoney> moneyList = new ArrayList<MyMoney>();
        MyMoney money1 = new MyMoney();
        money1.setCode("001");money1.setMoney(100);
        moneyList.add(money1);
        MyMoney money2 = new MyMoney();
        money2.setCode("001");money2.setMoney(80);
        moneyList.add(money2);
        MyMoney money3 = new MyMoney();
        money3.setCode("002");money3.setMoney(90);
        moneyList.add(money3);
        MyMoney money4 = new MyMoney();
        money4.setCode("003");money4.setMoney(60);
        moneyList.add(money4);
        MyMoney money5 = new MyMoney();
        money5.setCode("002");money5.setMoney(30);
        moneyList.add(money5);

        Collections.sort(moneyList, new Comparator<MyMoney>() {
            @Override
            public int compare(MyMoney o1, MyMoney o2) {
                int m1 = o1.getMoney();
                int m2 = o2.getMoney();
                if (m1 > m2) {
                    return 1;
                } else if (m1 == m2) {
                    return 0;
                } else {
                    return -1;
                }
            }
        });

        for(int i=0;i<moneyList.size();i++)
        {
            MyMoney news=(MyMoney)moneyList.get(i);

            System.out.println("code:"+map.get(news.getCode())+"  money:"+news.getMoney()+"  排名"+(i+1)+"\r\n");

        }

下面是MyMoney对象类
public class MyMoney {

private String code;
private Integer money;

public MyMoney(){}

public String getCode() {
    return code;
}

public void setCode(String code) {
    this.code = code;
}

public Integer getMoney() {
    return money;
}

public void setMoney(Integer money) {
    this.money = money;
}

}

代码可以直接拿来用，我已测过，望采纳

这是执行结果：
code:李四  money:30  排名1

code:王五  money:60  排名2

code:张三  money:80  排名3

code:李四  money:90  排名4

code:张三  money:100  排名5

size未知不要紧，只要用 list.length 就可以得到大小
但是你排序的规则是什么，你有两个001两个002，是所有的积分求和还是取最大的那个？
无论哪种，都可以借助一个 HashMap将人名和分数连起来，然后用 sort 排序
说清楚可以帮你写一个。

   private void sort( List<Double> valueList,List<String> nameList) {
        List<Double> xValue = new ArrayList<>();
        List<String> xName = new ArrayList<>();
        int de;
        int i = 0;
        Iterator<Double> it = valueList.iterator();
        while(it.hasNext()){
            de = 0;
            for(int j = 0; j < valueList.size(); j ++) {
                if(valueList.get(de) < valueList.get(j)) {
                    de = j;
                }
            }
            xValue.add(i,valueList.get(de));
            valueList.remove(de);
            xName.add(i,nameList.get(de));
            nameList.remove(de);
            i++;
        }
        valueList = xValue;
        nameList = xName;
    }


  public static  void main(String []fsdsf) {
        List<Double> yValue = new ArrayList<>();
        List<String> yName = new ArrayList<>();
        yValue.add(9.0);
        yName.add("aa");

        yValue.add(12.0);
        yName.add("bb");

        yValue.add(3.0);
        yName.add("cc");

        yValue.add(7.0);
        yName.add("dd");

        List<Double> xValue = new ArrayList<>();
        List<String> xName = new ArrayList<>();

        int de;
        int i = 0;
        Iterator<Double> it = yValue.iterator();
        while(it.hasNext()){
            de = 0;
            for(int j = 0; j < yValue.size(); j ++) {
                if(yValue.get(de) < yValue.get(j)) {
                    de = j;
                }
            }
            xValue.add(i,yValue.get(de));
            yValue.remove(de);
            xName.add(i,yName.get(de));
            yName.remove(de);
            i++;
        }

        for (Double d : xValue ) {
            System.out.println(d);
        }

        for (String d : xName ) {
            System.out.println(d);
        }

    }

https://blog.csdn.net/qq_38974073/article/details/88757725
java对两个有对应关系的list进行排序

实现思路：先对积分进行排序，排好序就基本差不多了，再把名字塞进去就行了

    public static void main(String[] args) {
        //数据
        ArrayList<User> listUser = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User u = new User();
            u.id = i;
            u.name = "张三" + i;
            listUser.add(u);
        }
        System.out.println(JSON.toJSONString(listUser));
        ArrayList<Integral> listIntegral = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            Integral in = new Integral();
            in.id = i % 5;
            in.integral = random.nextInt(100);
            listIntegral.add(in);
        }
        System.out.println(JSON.toJSONString(listIntegral));

        //先对积分排序
        Collections.sort(listIntegral);
        //将user根据id存成map，减少时间复杂度
        HashMap<Long, String> mapUser = new HashMap<>();
        for (User user : listUser) {
            mapUser.put(user.id, user.name);
        }

        ArrayList<Result> listResult = new ArrayList<>();
        //按顺序遍历就是了
        for (Integral in : listIntegral) {
            Result r = new Result();
            r.id = in.id;
            r.integral = in.integral;
            r.name = mapUser.get(in.id);
            listResult.add(r);
        }
        //最终结果
        System.out.println(JSON.toJSONString(listResult));
    }

    static class User {
        public long id;
        public String name;
    }

    static class Integral implements Comparable<Integral> {
        public long id;
        public long integral;

        @Override
        public int compareTo(Integral in) {//排序
            return integral - in.integral > 0 ? 1 : -1;
        }
    }

    static class Result extends User {
        public long integral;
    }

问答版主就是牛，从现在起只回论坛，不在踏入问答半步