为什么String.equalsIgnoreCase太慢了

Question

我在面试中遇到一个问题,即写一个方法来检查类似的单词而不考虑字符情况.

我通过使用每对字符的ASCII值的差异来回答它.但是在家里,当我在String.class中实际执行它时,我感到很不安 - 为什么这样实现呢!

我试图在inbuilt和我的自定义方法之间进行比较,这种方式 -

public class EqualsIgnoreCase {

    public static void main(String[] args) {
        String str1 = "Srimant @$ Sahu 959s";
        String str2 = "sriMaNt @$ sAhu 959s";

        System.out.println("Avg millisecs with inbuilt () - " + averageOfTenForInbuilt(str1, str2));
        System.out.println("\nAvg millisecs with custom () - " + averageOfTenForCustom(str1, str2));
    }

    public static int averageOfTenForInbuilt(String str1, String str2) {
        int avg = 0;
        for (int itr = 0; itr < 10; itr++) {
            long start1 = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                str1.equalsIgnoreCase(str2);
            }
            avg += System.currentTimeMillis() - start1;
        }
        return avg / 10;
    }

    public static int averageOfTenForCustom(String str1, String str2) {
        int avg = 0;
        for (int itr = 0; itr < 10; itr++) {
            long start2 = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                isEqualsIgnoreCase(str1, str2);
            }
            avg += System.currentTimeMillis() - start2;
        }
        return avg / 10;
    }

    public static boolean isEqualsIgnoreCase(String str1, String str2) {
        int length = str1.length();
        if (str2.length() != length) {
            return false;
        }

        for (int i = 0; i < length; i++) {
            char ch1 = str1.charAt(i);
            char ch2 = str2.charAt(i);

            int val = Math.abs(ch1 - ch2);
            if (val != 0) {
                if (isInAlphabetsRange(ch1, ch2)) {
                    if (val != 32) {
                        return false;
                    }
                } else {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean isInAlphabetsRange(char ch1, char ch2) {
        return (((ch1 <= 122 && ch1 >= 97) || (ch1 <= 90 && ch1 >= 65)) && ((ch2 <= 122 && ch2 >= 97) || (ch2 <= 90 && ch2 >= 65)));
    }

}

输出 -

内置()的平均毫秒数 - 14

使用custom()的平均毫秒数 - 5

我发现内置方法的效率很高,因为有很多检查和方法调用.这种实施背后有什么具体原因吗？或者我在逻辑中遗漏了什么？

任何建议,将衷心感谢!

Answer 1

您的例程只处理ASCII字符.系统一个处理所有unicode字符.

考虑以下示例:

public class Test {

    public static void main(String[] args) {
        System.out.println((int) '?'); // => 283
        System.out.println((int) '?'); // => 282 
    }

}

Answer 2

您的方法在许多方面都不正确.例如,它考虑"!" 等于"B","B"等于"1",但"!" 不等于"1"(所以它不是传递的,因为我们期望等于方法).

是的,为该方法编写一个更快更简单的错误实现非常容易.一个公平的挑战是编写一个正确的挑战,即正确处理JDK实现所做的所有参数.

您可能还希望了解如何在Java中编写正确的微基准测试？获得更可靠的性能测量.

Answer 3

这可能不是唯一的原因,但是您的解决方案实际上并不适用于所有可能的字符串这一事实肯定是一个因素.

有一些(恼人的)语言环境,其中两个字符可能具有相同的大写但不是相同的小写字母.出于这个原因,为了工作(大多数情况下,请参阅土耳其语),规范实现必须比较字符串char-for-char的大小写.

您的实现可能在99%的时间内完美,特别是如果您只需要处理英语区域设置,但遗憾的是核心库实现不会做出这样的假设.