Me pregunto si hay una diferencia en el rendimiento entre

comprobar si un valor es mayor o menor que otro

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

y

comprobar si un valor no es igual a otro

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

y por qué?

Además: Lo que si puedo comparar a cero, hay una mayor diferencia?

Sería bueno si las respuestas también la posibilidad de assebled ver en el código.

EDICIÓN:
Como la mayoría de ustedes señaló la diferencia en el rendimiento de curso es insignificante, pero estoy interesado en la diferencia en el nivel del cpu. Que la operación es más compleja?

Para mí es más una pregunta para aprender /comprender la técnica.

He quitado el Java etiqueta, que he añadido accidentalmente debido a que la pregunta estaba destinado general, no sólo basado en Java, lo siento.

InformationsquelleAutor das Keks | 2013-09-03

6 Comentarios

  1. 28

    Aún debe hacer lo que es más claro, más seguro y más fácil de entender. Estos micro-afinación de los debates son normalmente una pérdida de tiempo porque

    • que rara vez hacen una diferencia significativa
    • cuando hacen una diferencia esto puede cambiar si usted usa una diferente de la JVM, o el procesador. es decir, sin advertencia.

    Nota: la máquina generado también puede cambiar con el procesador o JVM, así que mirando esto no es muy útil en la mayoría de los casos, incluso si usted está muy familiarizado con el código de ensamblado.

    Lo que es mucho, mucho más importante es la capacidad de mantenimiento del software.

    • +1 siempre me ha gustado sus respuestas a la pregunta sobre el rendimiento y la eficiencia. Especialmente porque soy demasiado malo en ello 🙂
    • O te das cuenta de que no es tan fácil como adivinando lo que podría ser una buena idea. Es muy difícil encontrar un ejemplo de lo que es mejor para las actuaciones de la razón, incluso si es más oscuro.
    • De acuerdo. La oscuridad, por el bien de rendimiento no debería ser considerada a menos que las necesidades de su aplicación para que se ejecute de la forma más óptima posible (Tal como se ejecuta en entornos con limitaciones de memoria/informática habilidades, o algunos ultra-complejos de simulación que necesita tanto el jugo como sea posible). De lo contrario, usted está perdiendo todo ese espacio libre, yo.
    • De acuerdo, y usted puede probar que el más oscuro, el código es en realidad más rápido. 😉 Esto es a menudo ausente. Por CIERTO, La JVM optimiza común/patrones específicos de código. Esto significa que si usted utiliza un raro patrón (en la medida en que la JVM se refiere) el código es probable ser más lento no es más rápido, incluso si, en teoría, podría ser más rápido si utiliza un compilador diferente.
    • Honestamente, estoy molesto por respuestas como estas. Mi aplicación se ejecuta en un determinado JVM con determinadas especificaciones y tengo un solo bucle con un par de instrucciones que deben ejecutarse tantas veces como sea posible en un corto periodo de tiempo. Incluso mover un método de una instrucción if y guardando el resultado en una variable para luego poner esa variable en el caso de hacerse claramente un impacto medible!
    • Le sugiero que trate de usar JMH. Incluso si usted guarda el valor en un campo puede ser optimizado de distancia.
    • ponerlo en un campo producido un notable aumento del rendimiento, que está la cosa, es algo no relacionado a la pregunta original. Algo que usted no esperaría que la velocidad es en absoluto en realidad hizo un impacto, por lo que estoy bastante seguro de que cada pequeña cosa que puede hacer un impacto.
    • No estoy seguro de por qué esta es la respuesta más votada, como el OP se formuló una pregunta en relación con el rendimiento, no el software de las mejores prácticas de ingeniería.

  2. 15

    El rendimiento es absolutamente insignificante. Aquí está el código para probarlo:

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

    Los resultados:

    Test One: 342
    Test Two: 332
    Test One: 340
    Test Two: 340
    Test One: 415
    Test Two: 325
    Test One: 393
    Test Two: 329
    
    • +1 En mi última carrera tengo Test One: 113 Test Two: 113 en mi portátil.
    • Usted debe utilizar el Sistema.nanoTime() para la evaluación comparativa, que le da más precisión.
    • gracias! De alguna manera yo no había aprendido todavía. Lo que más me gusta es que ahora no necesito importar java.util.Date. Aunque, el javadoc dice que «Este método proporciona una precisión de nanosegundos, pero no necesariamente resolución de nanosegundos (que es la frecuencia de los cambios de valor) – no hay garantías, salvo que la resolución es al menos tan buena como la de currentTimeMillis().» Así que, no necesariamente confiar en la exactitud de la extra de precisión.
    • Yo no confianza Date().getTime() – está creando un nuevo objeto a medir el tiempo, que en realidad puede ocultar el punto de referencia. ¿Por qué no utilizar nanoTime() o al menos currentTimeMillis() (que es uno de los más rápidos llamadas por cierto)?
    • Usted debe utilizar JMH para microbenchmarks.
  3. 4

    Rara vez hay un impacto en el rendimiento, pero la primera es mucho más confiable, ya que se ocupará tanto de la extraordinaria casos donde

    1. y < 0 para empezar
    2. x o y están en mal estado con el interior del bloque.
    • Cabe destacar que más tipos de apoyo != de < (todos los iteradores, por ejemplo, a diferencia de los iteradores de acceso aleatorio), así != se utiliza generalmente para la consistencia.
  4. 1

    Otras personas parecen haber respondido de una medida perspectiva, sino desde el nivel de equipo que estaría interesado en la Unidad de la Lógica Aritmética (ALU), que se encarga de la mathy bits en un «ordenador normal». No parece ser un muy buen detalle en Cómo se hace menor que y mayor que la de trabajar en un nivel lógico en binario? para los detalles completos.

    Puramente un nivel lógico, la respuesta corta es que es más fácil de decir si algo no es algo que es para decir si algo es relativo a algo, sin embargo, esto probablemente ha sido optimizado en su estándar de computadora personal o servidor, por lo que solo verás los aumentos reales probable que en las pequeñas personal se construye como ordenadores de a bordo para aviones teledirigidos o de otros micro-tecnologías.

  5. 0

    Ahora, 6 años más tarde y después sigue recibiendo notificaciones ocasionales de esta pregunta me gustaría añadir algunas ideas que he adquirido durante mi equipo de ciencia de estudio.

    Poner las declaraciones anteriores en un pequeño programa y compilarlo…

    public class Comp {
        public static void main(String[] args) {
            int y = 42;
    
            for(int x = 0; x < y; x++) {
                //stop if x >= y
            }
    
            for(int x = 0; x != y; x++) {
                //stop if x == y
            }
        }
    }
    

    … se obtiene el siguiente código de bytes:

      public static void main(java.lang.String[]);
        Code:
           //y = 42
           0: bipush        42  
           2: istore_1
    
           //first for-loop
           3: iconst_0
           4: istore_2
           5: iload_2
           6: iload_1
           7: if_icmpge     16      //jump out of loop if x => y
          10: iinc          2, 1
          13: goto          5
    
           //second for-loop
          16: iconst_0
          17: istore_2
          18: iload_2
          19: iload_1
          20: if_icmpeq     29      //jump out of loop if x == y
          23: iinc          2, 1
          26: goto          18
    
          29: return
    

    Como podemos ver, en bytecode nivel de ambos se tratan de la misma manera y el uso de un único código de bytes de la instrucción para la comparación.

    Como ya se ha dicho, cómo el bytecode que se traduce en ensamblador/código de la máquina depende de la JVM.
    Pero en general esto condicional saltos puede ser traducido a algunos asamblea código como este:

    ; condition of first loop
    CMP eax, ebx
    JGE label  ; jump if eax > ebx
    
    ; condition of second loop
    CMP eax, ebx
    JE  label  ; jump if eax == ebx
    

    A nivel de hardware JGE y JE tienen la misma complejidad.

    Así que de todo en todo: en Relación con el rendimiento, tanto x < y y x != y son, en teoría, el mismo en el nivel de hardware y no es per se más rápido o más lento que los otros.

  6. -2

    Pregunto si anidada para cada prueba, los mismos resultados ?

    for(int x = 0; x < y; x++)
    {   
      for(int x2 = 0; x2 < y; x2++)  {}   
    }
    
    for(int x = 0; x != y; x++)
    {
      for(int x2 = 0; x2 != y; x2++) {}    
    }
    
    • ¿por qué esto obtener un upvote? Prueba por ti mismo y, a continuación, nos proporcionan una respuesta, no a otra pregunta.

Dejar respuesta

Please enter your comment!
Please enter your name here