Pourquoi est-Chaîne.equalsIgnoreCase est si lent

J'ai rencontré une question en entrevue pour écrire une méthode pour vérifier les mots similaires indépendamment des cas de caractères.

J'y ai répondu en utilisant la différence de valeur ASCII pour chaque paire de caractères. Mais à la maison, quand je suis passé par la mise en œuvre réelle de celui-ci dans la chaîne.classe, je suis dérangé-Pourquoi est-il mis en œuvre de cette façon!

J'ai essayé de faire une comparaison entre intégré et ma méthode personnalisée, de cette façon-

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

}

Sortie-

Millisecs Avg avec intégré () - 14

Millisecs Avg avec custom () - 5

J'ai trouvé que la méthode intégrée frappait l'efficacité, comme à cause de beaucoup de vérifications et d'appels de méthode. Y a-t-il des raisons spécifiques derrière une telle mise en œuvre? Ou est-ce que je manque quelque chose dans ma logique?

Toutes les suggestions, sera chaleureusement apprécié!