Question

我无法使用我想拥有ĄrakówMedyczna 1KrakówMedyczna 2，KrakówMedyczna 13的地址对字符串进行排序。但是首先我有：克拉科夫Medyczna 2，克拉科夫Medyczna 13，ĄrakówMedyczna 1和第二个：：rakówMedyczna 1，克拉科夫Medyczna 13，克拉科夫Medyczna 2

ArrayList<String> names = new ArrayList<String>();
names.add("Kraków, Medyczna 13");
names.add("Ąraków, Medyczna 1");
names.add("Kraków, Medyczna 2");
Collections.sort(names);
Collections.sort(names, Collator.getInstance(new Locale("PL")));
for(String s : names){
    System.out.println(s);
}
Collections.sort(names, new Comparator<String>() {
    public int compare(String o1, String o2) {

        String o1StringPart = o1.replaceAll("\\d", "");
        String o2StringPart = o2.replaceAll("\\d", "");

        if(o1StringPart.equalsIgnoreCase(o2StringPart))
        {
            return extractInt(o1) - extractInt(o2);
        }
        return o1.compareTo(o2);
    }

    int extractInt(String s) {
        String num = s.replaceAll("\\D", "");
        // return 0 if no digits found
        return num.isEmpty() ? 0 : Integer.parseInt(num);
    }
});

for(String s : names){
    System.out.println(s);    
}

Answer 1

您想逐部分比较完全由数字（数字）和完全由非数字（文本）组成的部分。

下面的比较循环（文本，数字？）。

如果只有一个字符串以数字开头，则它的第一部分为空文本，并且会被认为较小。

Collections.sort(names, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            Pattern digits = Pattern.compile("\\d+");
            Matcher m1 = digits.matcher(o1);
            Matcher m2 = digits.matcher(o2);
            int i1 = 0;
            int i2 = 0;
            while (i1 < o1.length() && i2 < o2.length()) {
                boolean b1 = m1.find();
                int j1 = b1 ? m1.start() : o1.length();
                boolean b2 = m2.find();
                int j2 = b2 ? m2.start() : o2.length();
                String part1 = o1.substring(i1, j1);
                String part2 = o2.substring(i2, j2);
                int cmp = String.compareIgnoreCase(part1, part2);
                if (cmp != 0) {
                    return;
                }
                if (b1 && b2) {
                    int num1 = Integer.parseInt(m1.group());
                    int num2 = Integer.parseInt(m2.group());
                    cmp = Integer.compare(num1, num2);
                    i1 = m1.end();
                    i2 = m2.end();
                } else if (b1) {
                    return -1;
                } else if (b2) {
                    return 1;
                }
            }
            return 0;
        }
    });

在Java 8中，具有所谓的lambda：

Collections.sort(names, (o1, o2) -> {
            Pattern digits = Pattern.compile("\\d+");
            Matcher m1 = digits.matcher(o1);
            Matcher m2 = digits.matcher(o2);
            int i1 = 0;
            int i2 = 0;
            while (i1 < o1.length() && i2 < o2.length()) {
                boolean b1 = m1.find();
                int j1 = b1 ? m1.start() : o1.length();
                boolean b2 = m2.find();
                int j2 = b2 ? m2.start() : o2.length();
                String part1 = o1.substring(i1, j1);
                String part2 = o2.substring(i2, j2);
                int cmp = String.compareIgnoreCase(part1, part2);
                if (cmp != 0) {
                    return;
                }
                if (b1 && b2) {
                    int num1 = Integer.parseInt(m1.group());
                    int num2 = Integer.parseInt(m2.group());
                    cmp = Integer.compare(num1, num2);
                    i1 = m1.end();
                    i2 = m2.end();
                } else if (b1) {
                    return -1;
                } else if (b2) {
                    return 1;
                }
            }
            return 0;
        });

这很冗长，自Java 9开始就有一个“简单”的解决方案：只需将所有数字的格式设置为固定宽度即可，在此处用零填充左至10位。

Collections.sort(names, (o1, o2) ->
    Strings.compareIgnoreCase(
            o1.replaceAll("\\d+", mr -> String.format("%010d", Integer.parseInt(mr.group())),
            o2.replaceAll("\\d+", mr -> String.format("%010d", Integer.parseInt(mr.group())))
    );

从Java 9开始，有一个String.replaceAll重载，可以将其传递给替换函数。

即使不重复自己，也会更加优雅：

Function<String, String> numFormatter = s -> s.replaceAll("\\d+",
        mr -> String.format("%010d", Integer.parseInt(mr.group())));
Collections.sort(names, (o1, o2) ->
        Strings.compareIgnoreCase(numFormatter.apply(o1), numFormatter.apply(o2.))
    );

最后，存在一个实用程序函数，用于进行任何转换或传递字段Comparator.comparing(converter)和Comparator.comparing(converter, otherComparator)的getter。

要按您的语言环境/语言对其进行排序：

Locale locale = new Locale("pl", "PL");
Collator collator = Collator.getInstance(locale); // How to sort on special letters
Function<String, String> numFormatter = s -> s /*.toUpperCase(locale)*/ .replaceAll("\\d+",
        mr -> String.format("%010d", Integer.parseInt(mr.group())));
Collections.sort(names, Comparator.comparing(numFormatter, collator));

整理器是一个比较器，但具有给定语言的内置排序功能。在重音字母上表现更好。我将不区分大小写的比较放在这里，因为可能不需要它。否则请使用String.toUpperCase(Locale)。

这有点多，我不能完全确定Android的java，也不知道代码是否可以编译（typos），但是很有趣。

Answer 2

您的自定义比较器几乎可以用，您只是忘了为波兰字符集使用正确的比较。在正常的字符串比较中，“Ą”在“ K”之后。

更改

return o1.compareTo(o2);

到

return Collator.getInstance(new Locale("PL")).compare(o1, o2);

Java android列表字符串排序带有数字和国家字母的字符串

2 个答案: