Question

我有包含数字的字符串列表：

示例：

String 1.0.2
String 2.1.2
String 10.0.1
String 3.0.1
String 2.3.1
String 10.2.1

我需要对此列表进行排序并获取此信息：

String 1.0.2
String 2.1.2
String 2.3.1
String 3.0.1
String 10.0.1
String 10.2.1

但是，如果我使用java函数Collections.sort我得到这个：

String 1.0.2
String 10.0.1
String 10.2.1
String 2.1.2
String 2.3.1
String 3.0.1

编辑：

我尝试过这个比较器：

public int compare(String o1, String o2) {
    int a = Integer.parseInt(o1.split(" ")[1].replace(".", ""));
    int b = Integer.parseInt(o2.split(" ")[1].replace(".", ""));

    return a-b;
}

当我运行应用程序时，我收到此错误java.lang.NumberFormatException: For input string: "Unknown"我如何检查是否存在不包含数字的字符串，以便我可以测试此比较器？

Answer 1

您可以获取这些字符串的数值并使用java8流

List<String> myList = Arrays.asList("String 1.0.2", "String 2.1.2", "String 10.0.1", "String 3.0.1",
            "String 2.3.1", "String 10.2.1");

myList.sort((x, y) -> Integer.compare(Integer.parseInt(x.replace(".", "").split(" ")[1]),
            Integer.parseInt(y.replace(".", "").split(" ")[1])));
System.out.println(myList);

Answer 2

相反，您可以使用这样的比较器：

List<String> list = Arrays.asList("1.0.2", "2.1.2", "10.0.1", "3.0.1", "2.3.1", "10.2.1");
System.out.println(list);
Collections.sort(list, (o1, o2) -> {
    return Integer.parseInt(o1.replace(".", "")) - Integer.parseInt(o2.replace(".", ""));
});
System.out.println(list);

<强>输出

[1.0.2, 2.1.2, 10.0.1, 3.0.1, 2.3.1, 10.2.1]
[1.0.2, 2.1.2, 2.3.1, 3.0.1, 10.0.1, 10.2.1]

这个想法是：

将所有.替换为空
将您的号码转换为正确的号码
比较任何数字的结果。

Answer 3

你可以写一个比较器，如：

@Override
public int compare(String o1, String o2) {
    int a = Integer.parseInt(o1.split(" ")[1].replace(".", ""));
    int b = Integer.parseInt(o2.split(" ")[1].replace(".", ""));
    return a - b;
}

然后只是：

CustomComparator comp = new CustomComparator();
Collections.sort(list, comp);

希望它有帮助！

Answer 4

您需要对它们进行标记，然后从最重要的标记到结尾进行比较。作为示例您可以按照以下步骤比较两个序列a和b。

    public int compare(Sring a,String b){
        String[] aToken = a.slpit(".");
        String[] bToken = b.slpit(".");
        if (aToken.length > bToken.length){
            return 1;
         }
        if (bToken.length > aToken.length){
            return -1;
        }
        for (int i=0; i<bToken.length; i++){
            if (aToken[i].compareTo(b[i]Token) != 0){
               return aToken[i].compareTo(bToken[i]);
           }
       }
      return 0;
    }

从这个片段中你可以构建你的比较器希望这个帮助

Answer 5

我已经解决了这个比较器的问题：

public int compare(String o1, String o2)
        {
            String a = o1.toString();
            String b = o2.toString();

            int ia = 0, ib = 0;
            int nza = 0, nzb = 0;
            char ca, cb;

            while (true) {
                // Only count the number of zeroes leading the last number compared
                nza = nzb = 0;

                ca = charAt(a, ia);
                cb = charAt(b, ib);

                // skip over leading spaces or zeros
                while (Character.isSpaceChar(ca) || ca == '0') {
                    if (ca == '0') {
                        nza++;
                    } else {
                        // Only count consecutive zeroes
                        nza = 0;
                    }

                    ca = charAt(a, ++ia);
                }

                while (Character.isSpaceChar(cb) || cb == '0') {
                    if (cb == '0') {
                        nzb++;
                    } else {
                        // Only count consecutive zeroes
                        nzb = 0;
                    }

                    cb = charAt(b, ++ib);
                }

                // Process run of digits
                if (Character.isDigit(ca) && Character.isDigit(cb)) {
                    int bias = compareRight(a.substring(ia), b.substring(ib));
                    if (bias != 0) {
                        return bias;
                    }
                }

                if (ca == 0 && cb == 0) {
                    // The strings compare the same. Perhaps the caller
                    // will want to call strcmp to break the tie.
                    return nza - nzb;
                }
                if (ca < cb) {
                    return -1;
                }
                if (ca > cb) {
                    return +1;
                }

                ++ia;
                ++ib;
            }
        }

        int compareRight(String a, String b)
        {
            int bias = 0, ia = 0, ib = 0;

            // The longest run of digits wins. That aside, the greatest
            // value wins, but we can't know that it will until we've scanned
            // both numbers to know that they have the same magnitude, so we
            // remember it in BIAS.
            for (;; ia++, ib++)
            {
                char ca = charAt(a, ia);
                char cb = charAt(b, ib);

                if (!Character.isDigit(ca) && !Character.isDigit(cb)) {
                    return bias;
                }
                if (!Character.isDigit(ca)) {
                    return -1;
                }
                if (!Character.isDigit(cb)) {
                    return +1;
                }
                if (ca == 0 && cb == 0) {
                    return bias;
                }

                if (bias == 0) {
                    if (ca < cb) {
                        bias = -1;
                    } else if (ca > cb) {
                        bias = +1;
                    }
                }
            }
        }

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

排序包含数字的字符串

5 个答案: