在Java中對字符串排序

Question

我有一個List<Bean> ，其中有對象值String 。 這些字符串如下所示：“這是1”，“這是10”，“這是2”，“這是11”
我的問題是如何使用番石榴將它們排序為1、2、10、11的順序？

List<Bean> orderedList = new ArrayList<>();
    Function<Bean, String> getNameFunction = new Function<Bean, String>() {
        @Override
        public String apply(Bean from) {
            return from.getShape();
        }
    };
    Ordering<Bean> nameOrdering = Ordering.natural().onResultOf(getNameFunction);
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(
            nameOrdering).addAll(lb).build();
    orderedList.addAll(sortedShapes);
    return orderedList;

這不起作用，我希望它像1，10，11，2那樣對它們進行排序
你能幫我么？
謝謝！

Answer 1

Java中String的自然排序是按字典順序。 您需要創建或找到所需的Comparator實現。 如果您自己編寫，則可以僅創建Ordering的子類。 然后，您可以執行以下操作：

Ordering<Bean> nameOrdering = myStringOrdering.onResultOf(getNameFunction);

Answer 2

Java Strings的默認（自然）排序是lexicographical ，這意味着Strings按其組成字母 （通過字符比較的字符）的字母順序進行排序。 從String.compareTo文檔：

[...]如果它們（字符串）在一個或多個索引位置具有不同的字符，則令k為此類索引中的最小值； 然后字符串在位置k的字符具有
通過使用<運算符確定的較小值，在字典上在另一個字符串之前。

正如ColinD建議的那樣，您將需要一個Comparator的實現，該實現支持Strings字母數字排序。 這是一個例子：

    List<Bean> lb = new ArrayList<Bean>() {{
            add(new Bean("This is 1"));
            add(new Bean("This is 10"));
            add(new Bean("This is 11"));
            add(new Bean("This is 2"));
        }};
    final AlphaNumericComparator comparator= new AlphaNumericComparator();
    Ordering<Bean> nameOrdering = new Ordering<Bean>() {
        @Override public int compare(Bean left, Bean right) {
            return comparator.compare(left.getShape(),right.getShape());
        }
    };
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(nameOrdering).addAll(lb).build();
    List<Bean> orderedList = new ArrayList<>();
    orderedList.addAll(sortedShapes);
    System.out.println("orderedList:" + orderedList);

AlphaNumericComparator （由Pierre-Luc Paour撰寫）：

public class AlphaNumericComparator implements Comparator {
    int compareRight(String a, String b) {
        int bias = 0;
        int ia = 0;
        int ib = 0;
        for (; ; ia++, ib++) {
            char ca = charAt(a, ia);
            char cb = charAt(b, ib);
            if (!Character.isDigit(ca) && !Character.isDigit(cb))
                return bias;
            else if (!Character.isDigit(ca))
                return -1;
            else if (!Character.isDigit(cb))
                return +1;
            else if (ca < cb)
                if (bias == 0)
                    bias = -1;
                else if (ca > cb)
                    if (bias == 0)
                        bias = +1;
                    else if (ca == 0 && cb == 0)
                        return bias;
        }
    }

    public int compare(Object o1, Object o2) {
        String a = o1.toString();
        String b = o2.toString();
        int ia = 0, ib = 0;
        int nza = 0, nzb = 0;
        char ca, cb;
        int result;

        while (true) {
            nza = nzb = 0;
            ca = charAt(a, ia);
            cb = charAt(b, ib);
            while (Character.isSpaceChar(ca) || ca == '0') {
                if (ca == '0')
                    nza++;
                else
                    nza = 0;
                ca = charAt(a, ++ia);
            }

            while (Character.isSpaceChar(cb) || cb == '0') {
                if (cb == '0')
                    nzb++;
                else
                    nzb = 0;
                cb = charAt(b, ++ib);
            }
            if (Character.isDigit(ca) && Character.isDigit(cb))
                if ((result = compareRight(a.substring(ia), b.substring(ib))) != 0)
                    return result;

            if (ca == 0 && cb == 0)
                return nza - nzb;
            if (ca < cb)
                return -1;
            else if (ca > cb)
                return +1;
            ++ia;
            ++ib;
        }
    }

    static char charAt(String s, int i) {
        if (i >= s.length()) {
            return 0;
        } else
            return s.charAt(i);
    }
}