web-dev-qa-db-fra.com

Performance: plus grand/plus petit que vs pas égal à

Je me demande s’il existe une différence de performance entre 

vérifier si une valeur est supérieure/inférieure à une autre 

for(int x = 0; x < y; x++); // for y > x

et

vérifier si une valeur n'est pas égale à une autre 

for(int x = 0; x != y; x++); // for y > x

et pourquoi?

De plus: si je compare à zéro, y a-t-il une autre différence?

Ce serait bien si les réponses envisageaient également une vue globale du code.

EDIT: Comme la plupart d'entre vous l'ont souligné, la différence de performances est bien sûr négligeable, mais je m'intéresse à la différence au niveau du processeur. Quelle opération est plus complexe? 

Pour moi, c’est plus une question d’apprendre/comprendre la technique. 

J'ai supprimé la balise Java, que j'ai ajoutée par inadvertance, car la question ne visait généralement pas uniquement Java, désolé.

performancejvmcomparison
27
das Keks

Vous devez toujours faire ce qui est plus clair, plus sûr et plus facile à comprendre. Ces discussions de micro-réglage sont généralement une perte de temps, car

  • ils font rarement une différence mesurable
  • quand ils font une différence, cela peut changer si vous utilisez une machine virtuelle ou un processeur différent. c'est-à-dire sans préavis.

Remarque: la machine générée peut également changer avec le processeur ou la machine virtuelle Java. Il n'est donc pas très utile de chercher dans cette affaire, même si vous connaissez très bien le code d'assemblage.

Ce qui est beaucoup, beaucoup plus important, est la maintenabilité du logiciel.

24
Peter Lawrey

La performance est absolument négligeable . Voici un code pour le prouver:

public class OpporatorPerformance {
    static long y = 300000000L;

    public static void main(String[] args) {
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());

    }

    public static long testOne() {
        Date newDate = new Date();
        int z = 0;
        for(int x = 0; x < y; x++){ // for y > x
            z = x;
        }
        return new Date().getTime() - newDate.getTime();
    }

    public static long testTwo() {
        Date newDate = new Date();
        int z = 0;
        for(int x = 0; x != y; x++){ // for y > x
            z = x;
        }
        return new Date().getTime() - newDate.getTime();
    }

}

Les resultats:

Test One: 342
Test Two: 332
Test One: 340
Test Two: 340
Test One: 415
Test Two: 325
Test One: 393
Test Two: 329
15
James Dunn

Il y a rarement un impact sur les performances, mais le premier est beaucoup plus fiable car il gérera les deux cas extraordinaires où 

  1. y <0 pour commencer 
  2. x ou y sont mélangés à l'intérieur du bloc.
4
OldCurmudgeon

D'autres personnes semblent avoir répondu d'un point de vue mesuré, mais du point de vue de la machine, l'unité de logique arithmétique (ALU), qui gère les bits de calcul sur un "ordinateur normal", vous intéresserait. Il semble y avoir un assez bon détail dans Comment fonctionne moins que et plus que fonctionner à un niveau logique en binaire? pour plus de détails.

Du point de vue purement logique, la réponse courte est qu’il est plus facile de dire si quelque chose n’est pas quelque chose que de dire si quelque chose est relatif à quelque chose, bien que cela ait probablement été optimisé dans votre ordinateur personnel ou serveur standard. Vous ne verrez que des gains réels dans de petites constructions personnelles, telles que des ordinateurs de bord pour drones ou d'autres micro-technologies.

0
aetherwalker