Java: comparaison des entiers et des chaînes - Performances
J'ai une chaîne et un int, disons: String str = "12345"; Et int num = 12345;. Quelle est la façon la plus rapide de voir si elles sont identiques, str.equals("" + num) ou num == Integer.parseInt(str) (Ou existe-t-il une manière plus rapide?)?
Il s'agit du code source pour Integer.parseInt et String.equals
num == Integer.parseInt(str) va plus vite que str.equals("" + num)
str.equals("" + num) convertira d'abord num en chaîne qui est O(n) où n étant le nombre de chiffres du nombre. Ensuite, il effectuera à nouveau une concaténation de chaîne O(n) et enfin faire la comparaison de chaînes. La comparaison de chaînes dans ce cas sera un autre O(n) - n étant le nombre de chiffres du nombre). Donc en tout ~ 3 * O (n)
num == Integer.parseInt(str) convertira la chaîne en entier qui est O(n) à nouveau où n étant le nombre de chiffres du nombre. Et puis la comparaison d'entier est O (1). Donc juste ~ 1 * O (n)
Pour résumer, les deux sont O(n) - mais str.equals("" + num) a une constante plus élevée et est donc plus lente.
Je pense que num == Integer.parseInt(str) est une meilleure façon de faire la comparaison. Parce que str.equals("" + num) ce n'est pas la manière idéale de comparer les valeurs entières et cela créera également des objets constants String inutiles dans le pool String (ce qui entrave les performances).
Je suppose que vous pourriez également l'utiliser pour comparer ........
int p = 1234;
String Int = "1234";
String string = String.valueOf(p);
System.out.println(string + Int);
System.out.println(string.equals(Int));
code here