具有整数值的字符串排序列表-Java

我有这个字符串列表

Car1

Car2

Car3

......


Carn

我想根据列表中的数字对列表进行排序。
例如，如果我有

Car3、Car1、Car12、Car45

， 我希望它能像

Car1、Car3、Car12、Car45那样排序

我使用过
Collections.sort（）
，但它返回类似于
Car1、car12、car3、Car45的内容

我应该怎么做才能把它按正确的顺序排列呢？
您需要创建一个自定义比较器，按照您的要求进行排序。然后你可以打电话

Collections.sort(myList, myComparator)

看

您可以在此处阅读比较器：
使用以下内容：

class ComparatorOfNumericString implements Comparator<String>{

    public int compare(String string1, String string2) {
        // TODO Auto-generated method stub
        String a = string1.substring(3);
        String b = string2.split(3);
        return Integer.parseInt(a)-Integer.parseInt(b);
    }
}

你需要一个定制的比较器，比如

    Collections.sort(list, new Comparator<String>() {
        public int compare(String s1, String s2) {
            int i1 = Integer.parseInt(s1.replaceAll("\\D", ""));
            int i2 = Integer.parseInt(s2.replaceAll("\\D", ""));
            return Integer.compare(i1, i2);
        }
    });

Collections.sort（列表，新比较器（）{
公共整数比较（字符串s1、字符串s2）{
int i1=Integer.parseInt（s1.replaceAll（“\\D”，即“”）；
int i2=Integer.parseInt（s2.replaceAll（“\\D”，即“”）；
返回整数。比较（i1，i2）；
}
});
您需要对比较器使用
排序的重载。以下代码用于您的特定字符串（CarXXX）：

Collections.sort（carList，newcomparator（）{
公共整数比较（字符串s1、字符串s2）{
int t1=Integer.parseInt（s1.substring（3））；
int t2=整数.parseInt（s2.子字符串（3））；
返回t1-t2；
}
});
排序是按字典顺序进行的，因为字母表中的1小于3，比较器会忽略接下来的内容。
您需要做的是编写自己的比较器，这将剪切“Car”，只保留字符串中的数字，然后您需要将数字的字符串表示形式解析为int，并比较int（作为解决方案之一）
集合。sort（）正确，只需编写比较器即可：

public class testComp implements Comparator<String> {

@Override
public int compare(String o1, String o2) {
    int number1 = Integer.parseInt(o1.substring(3, o1.length()));
    int number2 = Integer.parseInt(o2.substring(3, o2.length()));
    if (number1 > number2) {
        return -1;
    } else {
        return 1;
    }
}

公共类testComp实现了Comparator{
@凌驾
公共整数比较（字符串o1、字符串o2）{
int number1=Integer.parseInt（o1.substring（3，o1.length（））；
int number2=Integer.parseInt（o2.substring（3，o2.length（））；
如果（编号1>编号2）{
返回-1；
}否则{
返回1；
}
}
Car1是一个对象，因此您必须为此创建一个自定义比较器。并指定它的排序性质

Collection.Sort（）
是根据其元素的自然顺序将指定列表按升序排序。举个例子：字符串类似于a-z，数字是0-9。但是对象没有任何自然顺序。
您需要为
集合指定一个自定义的
比较器
方法，用于定义字符串的顺序

这适用于字符串中任何位置的数字，也适用于没有数字的字符串（返回到普通字符串比较和自然排序）：

final Pattern intsOnly=Pattern.compile（\\d+）；
比较器比较器=新比较器（）{
@凌驾
公共整数比较（最终字符串string1，最终字符串string2）{
字符串int1=null；
字符串int2=null；
Matcher matcher1=intsOnly.Matcher（string1）；
if（matcher1.find（））{
int1=matcher1.group（）；
Matcher matcher2=intsOnly.Matcher（string2）；
if（matcher2.find（））{
int2=matcher2.group（）；
}
}
if（int1==null | | int2==null）{返回string1.compareTo（string2）；}
返回Integer.valueOf（int1.compareTo（Integer.valueOf（int2））；
}
};
Collections.sort（字符串、比较器）；

当然这意味着Truck1将在Car2之前出现，但根据你的问题，这就是你想要的

更新：
上述解决方案无法确保Car6在Truk6之前出现。如果您还希望在数字相等的情况下回到自然字符串顺序，请使用以下方法：

final Pattern intsOnly = Pattern.compile("\\d+");

Comparator<String> comparator = new Comparator<String>() {
    @Override
    public int compare(final String string1, final String string2) {
        String int1 = null;
        String int2 = null;
        Matcher matcher1 = intsOnly.matcher(string1);
        if (matcher1.find()) {
            int1 = matcher1.group();
            Matcher matcher2 = intsOnly.matcher(string2);
            if (matcher2.find()) {
                int2 = matcher2.group();
            }
        }
        int result = 0;
        if (int1 != null && int2 != null) {
            result = Integer.valueOf(int1).compareTo(Integer.valueOf(int2));
        }
        if (result == 0) {
            return string1.compareTo(string2);
        }
        else {
            return result;
        }
    }
};
Collections.sort(strings, comparator);

final Pattern intsOnly=Pattern.compile（\\d+）；
比较器比较器=新比较器（）{
@凌驾
公共整数比较（最终字符串string1，最终字符串string2）{
字符串int1=null；
字符串int2=null；
Matcher matcher1=intsOnly.Matcher（string1）；
if（matcher1.find（））{
int1=matcher1.group（）；
Matcher matcher2=intsOnly.Matcher（string2）；
if（matcher2.find（））{
int2=matcher2.group（）；
}
}
int结果=0；
if（int1！=null&&int2！=null）{
结果=Integer.valueOf（int1）.compareTo（Integer.valueOf（int2））；
}
如果（结果==0）{
返回string1.compareTo（string2）；
}
否则{
返回结果；
}
}
};
Collections.sort（字符串、比较器）；
这对你有用。但你不能有重复的

    String text = "Car3, Car1, Car12, Car45";
    String[] str = text.split(", ");
    Map<Integer,String> myMap=new HashMap<>();
    int[] numOnly=new int[str.length];
    for (int i = 0; i < str.length; i++) {
          numOnly[i] = Integer.parseInt(str[i].replaceAll("\\D", ""));
          myMap.put(numOnly[i],str[i]);
    }       
    System.out.println(myMap.values());

String text=“Car3，Car1，Car12，Car45”；
字符串[]str=text.split（“，”）；
Map myMap=newhashmap（）；
int[]numOnly=新的int[str.length]；
对于（int i=0；i
您看到了吗？检查此项使用减号比较整数时要小心-可能会溢出。+1用于解释字符串的字典顺序谢谢您的回答我已经这样做了，但我想确定这是唯一的方法还是我正在重新发明轮子：）使用减号比较整数时要小心-可能是verflow.@Howard如果有溢出问题，那么即使将值解析为整数也可能会有问题。+1，但为了性能，我会编译正则表达式并使用正匹配来提取数字。比较器通常是性能关键型的。请原谅我的无知，-1和1…它们表示什么？这只适用于最高级的数字字符串中的索引3。我确信“Car1”、“Car2”等只是一个示例。有关完整的解决方案，请参阅我的答案
final Pattern intsOnly = Pattern.compile("\\d+");

Comparator<String> comparator = new Comparator<String>() {
    @Override
    public int compare(final String string1, final String string2) {
        String int1 = null;
        String int2 = null;
        Matcher matcher1 = intsOnly.matcher(string1);
        if (matcher1.find()) {
            int1 = matcher1.group();
            Matcher matcher2 = intsOnly.matcher(string2);
            if (matcher2.find()) {
                int2 = matcher2.group();
            }
        }
        if (int1 == null || int2 == null) { return string1.compareTo(string2); }
        return Integer.valueOf(int1).compareTo(Integer.valueOf(int2));
    }
};
Collections.sort(strings, comparator);

final Pattern intsOnly = Pattern.compile("\\d+");

Comparator<String> comparator = new Comparator<String>() {
    @Override
    public int compare(final String string1, final String string2) {
        String int1 = null;
        String int2 = null;
        Matcher matcher1 = intsOnly.matcher(string1);
        if (matcher1.find()) {
            int1 = matcher1.group();
            Matcher matcher2 = intsOnly.matcher(string2);
            if (matcher2.find()) {
                int2 = matcher2.group();
            }
        }
        int result = 0;
        if (int1 != null && int2 != null) {
            result = Integer.valueOf(int1).compareTo(Integer.valueOf(int2));
        }
        if (result == 0) {
            return string1.compareTo(string2);
        }
        else {
            return result;
        }
    }
};
Collections.sort(strings, comparator);

    String text = "Car3, Car1, Car12, Car45";
    String[] str = text.split(", ");
    Map<Integer,String> myMap=new HashMap<>();
    int[] numOnly=new int[str.length];
    for (int i = 0; i < str.length; i++) {
          numOnly[i] = Integer.parseInt(str[i].replaceAll("\\D", ""));
          myMap.put(numOnly[i],str[i]);
    }       
    System.out.println(myMap.values());