在java中使用各自的值对重复键进行排序

我需要在我的项目中对门牌号进行排序。但我没有得到我的问题的确切逻辑

名单如下：

9-11, 9-01, 10-02, 10-01, 2-09, 3-88, 9-03

我需要将上述列表排序为：

2-09, 3-88, 9-01, 9-03, 9-11, 10-01, 10-02

我需要像上面那样的输出

---

有谁能帮我编写Java代码吗？

这里的逻辑很简单：

209<388<901<902<911<1001<1002

一种可能的解决办法是：

    String[] input = {"9-11", "9-01", "10-02", "10-01", "2-09", "3-88", "9-03"};
    Map<Integer, String> map = new TreeMap<Integer, String>();
    for (String s : input) {
        map.put(Integer.valueOf(s.replace("-", "")), s);
    }
    TreeSet<Integer> set = new TreeSet<Integer>(map.keySet());
    String[] output = new String[input.length];
    int i = 0;
    for (Integer key : set) {
        output[i++] = map.get(key);
    }

String[]输入={“9-11”、“9-01”、“10-02”、“10-01”、“2-09”、“3-88”、“9-03”}；
Map Map=newtreemap（）；
for（字符串s：输入）{
map.put（Integer.valueOf（s.replace（“-”，”），s）；
}
TreeSet set=新树集（map.keySet（））；
String[]输出=新字符串[input.length]；
int i=0；
for（整数键：设置）{
输出[i++]=map.get（键）；
}

如果希望支持更灵活的格式，可以实现Comparison以精确定义Comparison规则。让我们来看看修改的例子：

    class HouseNumber implements Comparable<HouseNumber>{
        private Integer house;
        private Integer flat;

        private HouseNumber(String s) {
            String[] fields = s.split("-");
            house = Integer.valueOf(fields[0]);
            flat = Integer.valueOf(fields[1]);
        }

        @Override
        public int compareTo(HouseNumber o) {
            if (house.compareTo(o.house) == 0) {
                return flat.compareTo(o.flat);
            } 
            return house.compareTo(o.house);
        }

    }

    String[] input = {"9-11", "9-01", "10-02", "10-01", "2-09", "3-88", "9-03"};
    Map<HouseNumber, String> map = new TreeMap<HouseNumber, String>();
    for (String s : input) {
        map.put(new HouseNumber(s), s);
    }
    TreeSet<HouseNumber> set = new TreeSet<HouseNumber>(map.keySet());
    String[] output = new String[input.length];
    int i = 0;
    for (HouseNumber key : set) {
        output[i++] = map.get(key);
    }

class HouseNumber实现可比性{
私人综合大楼；
私人整数单位；
私人门牌号（字符串s）{
字符串[]字段=s.split（“”）；
house=整数。valueOf（字段[0]）；
flat=整数。valueOf（字段[1]）；
}
@凌驾
公共内部比较（门牌号o）{
如果（内部比较）与（外部比较）=0{
返回平面。与（o平面）相比；
} 
返回房屋。与（o.房屋）相比；
}
}
字符串[]输入={“9-11”、“9-01”、“10-02”、“10-01”、“2-09”、“3-88”、“9-03”}；
Map Map=newtreemap（）；
for（字符串s：输入）{
地图放置（新门牌号）；
}
TreeSet set=新树集（map.keySet（））；
String[]输出=新字符串[input.length]；
int i=0；
用于（门牌号键：设置）{
输出[i++]=map.get（键）；
}

只需从列表中删除“-”

9-11, 9-01, 10-02, 10-01, 2-09, 3-88, 9-03

变成

911, 901, 1002, 1001, 209, 388, 903

分类

将“-”放在后面，从后面跳过两个位置

2-09, 3-88, 9-01, 9-03, 9-11, 10-01, 10-02

---

就这么简单

我已经和你们分享了解决的问题，也许它会帮助你们得到你们想要的

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class HouseNo {

    public HouseNo(String house, String block) {
        this.houseno = house;
        this.blockno = block;
    }

    private String houseno;
    private String blockno;

    public String getHouseno() {
        return houseno;
    }

    public void setHouseno(String houseno) {
        this.houseno = houseno;
    }

    public String getBlockno() {
        return blockno;
    }

    public void setBlockno(String blockno) {
        this.blockno = blockno;
    }

    public static class SortByHouseNo implements Comparator<HouseNo> {

        @Override
        public int compare(HouseNo o1, HouseNo o2) {
            Integer first = Integer.valueOf(o1.getHouseno());
            Integer second = Integer.valueOf(o2.getHouseno());

            Integer f1 = Integer.valueOf(o1.getBlockno());
            Integer f2 = Integer.valueOf(o2.getBlockno());

            if (first.compareTo(second) == 0) {
                return f1.compareTo(f2);
            }
            return first.compareTo(second);
        }
    }

    @Override
    public String toString() {
        return "House -> " + this.getHouseno() + "-" + this.getBlockno();
    }

    public static void main(String[] args) {
        // Final
        String houseList[] = { "9-11", "9-01", "10-02", "10-01", "2-09",
                "3-88", "9-03", "9-3" };

        HouseNo house = null;
        ArrayList<HouseNo> sortedList = new ArrayList<>();
        for (String string : houseList) {
            String h = string.substring(0, string.indexOf('-'));
            String b = string.substring(string.indexOf('-') + 1);
            house = new HouseNo(h, b);
            sortedList.add(house);
        }

        System.out.println("Before Sorting :: ");
        for (HouseNo houseNo : sortedList) {
            System.out.println(houseNo);
        }

        Collections.sort(sortedList, new SortByHouseNo());
        System.out.println("\n\nAfter Sorting HouseNo :: ");
        for (HouseNo houseNo : sortedList) {
            System.out.println(houseNo);
        }

    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
公务舱号{
公共房屋号（串屋、串座）{
this.houseno=房子；
this.blockno=块；
}
私人字符串编号；
私有字符串blockno；
公共字符串getHouseno（）{
返回号；
}
公共无效setHouseno（字符串houseno）{
this.houseno=houseno；
}
公共字符串getBlockno（）{
返回blockno；
}
公共块号（字符串块号）{
this.blockno=blockno；
}
公共静态类SortByHouseNo实现了Comparator{
@凌驾
公共整数比较（屋号o1、屋号o2）{
Integer first=Integer.valueOf（o1.getHouseno（））；
整数秒=Integer.valueOf（o2.getHouseno（））；
整数f1=Integer.valueOf（o1.getBlockno（））；
整数f2=整数.valueOf（o2.getBlockno（））；
如果（第一个比较到（第二个）==0）{
返回f1.compareTo（f2）；
}
首先返回。比较（第二）；
}
}
@凌驾
公共字符串toString（）{
返回“House->”+this.getHouseno（）+“-”+this.getBlockno（）；
}
公共静态void main（字符串[]args）{
//决赛
字符串houseList[]={“9-11”、“9-01”、“10-02”、“10-01”、“2-09”，
"3-88", "9-03", "9-3" };
HouseNo house=null；
ArrayList sortedList=新建ArrayList（）；
for（字符串：房屋列表）{
字符串h=String.substring（0，String.indexOf（'-'）；
字符串b=String.substring（String.indexOf（'-'）+1）；
房屋=新房屋编号（h，b）；
分类列表。添加（房屋）；
}
System.out.println（“排序前：：”；
用于（房屋编号房屋编号：分类列表）{
系统输出打印号（房屋号）；
}
Collections.sort（sortedList，new SortByHouseNo（））；
System.out.println（“\n\n分拣室编号：”；
用于（房屋编号房屋编号：分类列表）{
系统输出打印号（房屋号）；
}
}
}

更新的解决方案

你喜欢这样吗

您的比较器

class SimpleComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        String [] o1sub = o1.split("-");
        String [] o2sub = o2.split("-");
        int value1 = Integer.parseInt(o1sub[0]);
        int value2 = Integer.parseInt(o2sub[0]);
        if(value1!=value2){
            return new Integer (value1).compareTo(value2);
        }
        int value3 = Integer.parseInt(o1sub[1]);
        int value4 = Integer.parseInt(o2sub[1]);
        if(value3!=value4){
            return new Integer(value3).compareTo(value4);
        }
        return 0;

    }
}

排序

 Arrays.sort(array,new SimpleComparator());     
 System.out.println(Arrays.toString(array));

输出

[2-09, 3-88, 9-01, 9-03, 9-11, 10-01, 10-02]

---

您应该询问具体的问题，例如实现。这不是一个让别人帮你解决家庭作业的地方。你应该使用java.lang.Comparable和java.util.Comparator在你的项目中排序……谢谢你的回复。但是在输入中，如果我们给出9-3，那么这个值将首先打印，而不是2-09。那么排序并不是以完美的方式完成的我有更新的解决方案。。。再检查一遍。。不要使用另一个静态类“SortByBlock”，它是我为测试而开发的。。。使用其余的编码…感谢您的回复。但是在输入中，如果我们给出9-3，那么这个值将首先打印，而不是2-09。然后排序并不是以完美的方式完成的，但我假设要求只接受9-03格式（您以这种格式发布了所有数字）。当然，如果我们也必须接受9-3，那么解决方案需要扩展。感谢您的快速回复…不，在我的要求9-3格式中有。我该怎么处理这种情况呢非常感谢。。它工作得很好。你解决了我的大问题。

 Arrays.sort(array,new SimpleComparator());     
 System.out.println(Arrays.toString(array));

[2-09, 3-88, 9-01, 9-03, 9-11, 10-01, 10-02]