Est-ce que CONSTANT.equals (VARIABLE) est plus rapide que VARIABLE.equals (CONSTANT)?

J’ai eu une conversation intéressante avec l’un de mes coéquipiers.

Est-ce que CONSTANT.equals(VARIABLE) plus rapide que VARIABLE.equals(CONSTANT) en Java?

Je soupçonne que ceci est une fausse déclaration. Mais j’essaie de comprendre quel devrait être le raisonnement qualitatif derrière tout cela?

Je sais que dans les deux cas, la performance ne différera pas d’un état significatif. Mais c’était une recommandation dans le cadre des MEILLEURES PRATIQUES, ce qui me rend mal à l’aise. C’est la raison pour laquelle je cherche un bon raisonnement que je souhaite présenter avec ce cas.

S’il vous plaît HELP

Question interessante. Voici le test que j’ai écrit:

 public class EqualsTest { public static Ssortingng CONST = "const"; public void constEqVar(Ssortingng var) { CONST.equals(var); } public void varEqConst(Ssortingng var) { var.equals(CONST); } } 

Ensuite, je l’ai compilé avec javac: javac EqualsTest.java et javac EqualsTest.java désassemblé avec javap : javap -c EqualsTest .

Voici l’extrait pertinent de la sortie javap:

 public void constEqVar(java.lang.Ssortingng); Code: 0: getstatic #2; //Field CONST:Ljava/lang/Ssortingng; 3: aload_1 4: invokevirtual #3; //Method java/lang/Ssortingng.equals:(Ljava/lang/Object;)Z 7: pop 8: return public void varEqConst(java.lang.Ssortingng); Code: 0: aload_1 1: getstatic #2; //Field CONST:Ljava/lang/Ssortingng; 4: invokevirtual #3; //Method java/lang/Ssortingng.equals:(Ljava/lang/Object;)Z 7: pop 8: return 

Comme vous pouvez le constater, la seule différence entre ces deux méthodes est l’ordre des opérations: getstatic, puis aload_1 dans le premier cas et aload_1 + getstatic dans le deuxième cas.

Il est assez évident que le temps d’exécution ne doit pas dépendre de cet ordre.

La seule raison de préférer const.equals(var) plutôt que var.equals(const) est d’éviter NullPointerException .

Pour moi, ce n’est pas un problème de vitesse, c’est un problème de fiabilité.

par exemple

 "Hello".equals(a); // will never throw a NPE a.equals("Hello"); // can throw an NPE. 

Vous préférerez peut-être que ça explose quand a est null mais d’habitude je ne le fais pas.

Cela ne dépend que de la mise en œuvre de la méthode equals. Ça pourrait être plus rapide, ça pourrait être le plus lent et ça pourrait être la même chose … C’est souvent pareil. En outre, cela ne dépend pas du fait que l’un est une variable et l’autre d’une constante, mais du contenu des deux objects.

Un avantage de Constant.equals (variable) est que vous ne pouvez pas avoir d’exception NullPointerException sur le .equals

Faites un test simple avec Ssortingngs:

 final Ssortingng constHello = "Hello"; final int times = 1000000000; long constTimeStart = System.nanoTime(); for (int i = 0; i < times; ++i) { constHello.equals("Hello"); } long constTimeStop = System.nanoTime(); System.out.println("constHello.equals(\"Hello\"); " + times + " times: " + (constTimeStop - constTimeStart) + " ns"); constTimeStart = System.nanoTime(); for (int i = 0; i < times; ++i) { "Hello".equals(constHello); } constTimeStop = System.nanoTime(); System.out.println("\"Hello\".equals(constHello); " + times + " times: " + (constTimeStop - constTimeStart) + " ns"); 

Edit: Comme mentionné dans les commentaires ci-dessous, ce n’était pas une bonne façon de faire des micromésures. Changer la partie du code qui allait être exécuté en premier prouve que le temps de préchauffage joue ici un rôle important. Le premier test est toujours plus lent. Répéter le test plusieurs fois dans le même code pour corriger rapidement les résultats plus ou moins identiques.

Je suppose que Code dans java.langSsortingng prend en charge ma réponse.

  public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof Ssortingng) { Ssortingng anotherSsortingng = (Ssortingng)anObject; int n = count; if (n == anotherSsortingng.count) { char v1[] = value; char v2[] = anotherSsortingng.value; int i = offset; int j = anotherSsortingng.offset; while (n-- != 0) { if (v1[i++] != v2[j++]) return false; } return true; } } return false; } 

Une bonne comparaison peut être:

 private static Ssortingng EXAMPLE = "Example"; private Ssortingng obj = null; 

cas 1:

 if(obj.equals(EXAMPLE) { } 

Ceci est une exception jetée null pointeur ..

cas 2:

 if(EXAMPLE.equals(obj)) { } 

Cela ne jettera pas d’exception de pointeur null ..