在Java中使用2位数字对数组进行排序

我想对字符串数组进行排序，其中所有单元格都以1或2位数字开头，其余单元格包含文本。
但是，只有一个

Arrays.sort（myArray）

只是将排序与第一个数字进行比较，因此我得到以下结果：

1-XXX
10-XXX
12-XXX
2-XXX
24-XXX

---

有人有解决方案吗？

您需要为此提供自己的比较器。以下是一个例子：

Arrays.sort(yourArray, new Comparator<String>() {
    @Override
    public int compare(String string1, String string2) {
        int number1 = Integer.decode(string1.substring(0, string1.indexOf(" "))); // This assumes that there is always a space after the number
        int number2 = Integer.decode(string2.substring(0, string2.indexOf(" ")));
        return Integer.compare(number1, number2);
    }
});

Arrays.sort（yourray，newcomparator（）{
@凌驾
公共整数比较（字符串string1、字符串string2）{
int number1=Integer.decode（string1.substring（0，string1.indexOf（“”））；//这假设数字后面总是有一个空格
int number2=Integer.decode（string2.substring（0，string2.indexOf（“”））；
返回整数。比较（number1，number2）；
}
});

您需要为此提供自己的比较器。以下是一个例子：

Arrays.sort(yourArray, new Comparator<String>() {
    @Override
    public int compare(String string1, String string2) {
        int number1 = Integer.decode(string1.substring(0, string1.indexOf(" "))); // This assumes that there is always a space after the number
        int number2 = Integer.decode(string2.substring(0, string2.indexOf(" ")));
        return Integer.compare(number1, number2);
    }
});

Arrays.sort（yourray，newcomparator（）{
@凌驾
公共整数比较（字符串string1、字符串string2）{
int number1=Integer.decode（string1.substring（0，string1.indexOf（“”））；//这假设数字后面总是有一个空格
int number2=Integer.decode（string2.substring（0，string2.indexOf（“”））；
返回整数。比较（number1，number2）；
}
});

米沙提供了正确的答案，但作为一点乐趣，这也很有效：

Arrays.sort(arr, (s1, s2) -> 
{
  return (s1.charAt(1)-s2.charAt(1))*10 + s1.charAt(0)-s2.charAt(0);
});

---

米沙给出了正确的答案，但是，作为一点乐趣，这也很有效：

Arrays.sort(arr, (s1, s2) -> 
{
  return (s1.charAt(1)-s2.charAt(1))*10 + s1.charAt(0)-s2.charAt(0);
});

---

您可以使用正则表达式在自定义压缩程序中查找字符串开头的数字以进行排序。我选择使用正则表达式，因此数字的长度无关紧要，数字后面的内容也无关紧要。如果两个字符串都以数字开头，且数字不相同，则比较数字，如果不只是将两个字符串作为一个整体进行比较

Arrays.sort(array, (s1, s2) -> {
    Pattern pattern = Pattern.compile("^(\\d+)");

    Matcher matcher1 = pattern.matcher(s1);
    Matcher matcher2 = pattern.matcher(s2);

    if (matcher1.find() && matcher2.find()) {
        Integer i1 = Integer.valueOf(matcher1.group(1));
        Integer i2 = Integer.valueOf(matcher2.group(1));

        int compared = i1.compareTo(i2);
        if (compared != 0) {
            return compared;
        }
    }

    return s1.compareTo(s2);
});

对于示例阵列，这将输出：

1-XXX
2-XXX
10-XXX
12-XXX
24-XXX

---

1：如果数字相同，您仍然可以比较整个字符串，以便对数字之后的所有内容进行排序。

您可以使用正则表达式在自定义压缩程序中查找字符串开头的数字进行排序。我选择使用正则表达式，因此数字的长度无关紧要，数字后面的内容也无关紧要。如果两个字符串都以数字开头，且数字不相同，则比较数字，如果不只是将两个字符串作为一个整体进行比较

Arrays.sort(array, (s1, s2) -> {
    Pattern pattern = Pattern.compile("^(\\d+)");

    Matcher matcher1 = pattern.matcher(s1);
    Matcher matcher2 = pattern.matcher(s2);

    if (matcher1.find() && matcher2.find()) {
        Integer i1 = Integer.valueOf(matcher1.group(1));
        Integer i2 = Integer.valueOf(matcher2.group(1));

        int compared = i1.compareTo(i2);
        if (compared != 0) {
            return compared;
        }
    }

    return s1.compareTo(s2);
});

对于示例阵列，这将输出：

1-XXX
2-XXX
10-XXX
12-XXX
24-XXX

---

1：如果数字相同，您仍然可以比较整个字符串，这样数字之后的所有内容仍将被排序。

public class SortArray{

public static void main(String[] args) {

    List<Digit> listDigit = new ArrayList<Digit>();

    Digit digit1 = new Digit(1, "XXX");
    Digit digit2 = new Digit(10, "XXX");
    Digit digit3 = new Digit(12, "XXX");
    Digit digit4 = new Digit(2, "XXX");
    Digit digit5 = new Digit(24, "XXX");

    listDigit.add(digit2);
    listDigit.add(digit3);
    listDigit.add(digit1);
    listDigit.add(digit4);
    listDigit.add(digit5);

    for (Digit digit : listDigit) {
            System.out.println("Sort Before -  Digit: "+digit.getDigit() +" Name:"+digit.getName());
    }

    System.out.println(" -------------------//-------------------------");

     Collections.sort(listDigit, new SortbyDigit()); 

    for (Digit digit : listDigit) {
            System.out.println("Sort After -  Digit: "+digit.getDigit() +" Name:"+digit.getName());
    }

}

}

公共类SortbyDigit实现了Comparator{

 @Override
public int compare(Digit a, Digit b) 
{ 
    return a.getDigit() - b.getDigit(); 
} 

}

排序前-数字：10名称：XXX 排序前-数字：12名称：XXX 排序前-数字：1名称：XXX 排序前-数字：2名称：XXX 排序前-数字：24名称：XXX -------------------//------------------------- 排序后-数字：1名称：XXX 排序后-数字：2名称：XXX 排序后-数字：10名称：XXX 排序后-数字：12名称：XXX

---

排序后-数字：24名称：XXX

公共类排序{

public static void main(String[] args) {

    List<Digit> listDigit = new ArrayList<Digit>();

    Digit digit1 = new Digit(1, "XXX");
    Digit digit2 = new Digit(10, "XXX");
    Digit digit3 = new Digit(12, "XXX");
    Digit digit4 = new Digit(2, "XXX");
    Digit digit5 = new Digit(24, "XXX");

    listDigit.add(digit2);
    listDigit.add(digit3);
    listDigit.add(digit1);
    listDigit.add(digit4);
    listDigit.add(digit5);

    for (Digit digit : listDigit) {
            System.out.println("Sort Before -  Digit: "+digit.getDigit() +" Name:"+digit.getName());
    }

    System.out.println(" -------------------//-------------------------");

     Collections.sort(listDigit, new SortbyDigit()); 

    for (Digit digit : listDigit) {
            System.out.println("Sort After -  Digit: "+digit.getDigit() +" Name:"+digit.getName());
    }

}

}

公共类SortbyDigit实现了Comparator{

 @Override
public int compare(Digit a, Digit b) 
{ 
    return a.getDigit() - b.getDigit(); 
} 

}

排序前-数字：10名称：XXX 排序前-数字：12名称：XXX 排序前-数字：1名称：XXX 排序前-数字：2名称：XXX 排序前-数字：24名称：XXX -------------------//------------------------- 排序后-数字：1名称：XXX 排序后-数字：2名称：XXX 排序后-数字：10名称：XXX 排序后-数字：12名称：XXX

---

按数字排序：24 Name:XXX

您的输入是什么，输出是什么，您想要的输出是什么！使用自定义的

比较器

。大量的文献资料。也许在你的问题中也包括样本数据。还有创建示例数据的代码。否则每个人都需要复制粘贴您的表。这会减慢回答速度您的输入、输出和想要的输出是什么！使用自定义的

比较器

。大量的文献资料。也许在你的问题中也包括样本数据。还有创建示例数据的代码。否则每个人都需要复制粘贴您的表。这降低了答题速度，在number1==number2的情况下，比较文本的其余部分。这取决于OP和他希望文本的行为方式。在number1==number2的情况下，比较文本的其余部分。这取决于OP和他希望文本的行为方式