Java android 列表字符串对带有数字和国家/地区字母的字符串进行排序

Question

我无法使用我想要的地址对字符串进行排序: Ąraków Medyczna 1 Kraków Medyczna 2 、 Kraków Medyczna 13 。但首先我有:Kraków Medyczna 2、Kraków Medyczna 13、Ąraków Medyczna 1，第二个我有:Ąraków Medyczna 1、Kraków Medyczna 13、Kraków 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.))
    ); 

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

要按您的区域设置/语言对其进行排序:

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)); 

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

这有点多了，我不完全确定Android的java，或者代码是否可以编译(打字错误)，但是享受吧。