duplicados posibles:
Difference between i++ and ++i in a loop?
Is there a difference between x++ and ++x in java?¿cuál es la diferencia entre i ++ y ++ i for for loop (Java)?
hola, me acaba de comenzar el aprendizaje de Java y ahora estoy en la declaración de bucle. No entiendo cómo ++ i i ++ funciona en una declaración for loop.
Me refiero a cómo funcionan en operaciones matemáticas como la suma y la resta. Espero que alguien me explique esto.
Ambos incrementan el número. ++i es equivalente a i = i + 1.
i++ y ++i son muy similares, pero no exactamente lo mismo. Ambos incrementan el número, pero ++i incrementa el número antes de que se evalúe la expresión actual, mientras que i++ incrementa el número después de evaluar la expresión.
int i = 3;
int a = i++; // a = 3, i = 4
int b = ++a; // b = 4, a = 4
Para responder la pregunta real, sin embargo, son esencialmente idénticos dentro del contexto del típico uso del bucle 'for'. – Amber
Punto de pedantería: 'i = i + 1' es una expresión con un valor uno más que el valor inicial de' i', que lo haría más parecido a '++ i'. –
Tanto i++++i y son cortos de mano para i = i + 1.
Además de cambiar el valor de i, también devuelven el valor de i, antes de agregar uno (i++) o después de agregar uno (++i).
En un bucle, el tercer componente es una pieza de código que se ejecuta después de cada iteración.
for (int i=0; i<10; i++)
El valor de esa parte no se utiliza, por lo que lo anterior es sólo el mismo que
for(int i=0; i<10; i = i+1)
o
for(int i=0; i<10; ++i)
Cuando se hace una diferencia (entre i++ y ++i) es en estos casos
while(i++ < 10)
for (int i=0; i++ < 10;)
Ver la pedantería de TomH en la respuesta de David, i = i + 1 es idéntico a ++ i, no i ++ :-) – paxdiablo
La diferencia es que el operador de incremento posterior i++ devuelve i como lo era antes de de incrementación, y el operador de incremento previo ++i rendimientos i, ya que es después de incremento. Si estás preguntando acerca de un típico bucle for:
for (i = 0; i < 10; i++)
o
for (i = 0; i < 10; ++i)
Son exactamente lo mismo, ya que no se está utilizando i++++i o como parte de una expresión mayor.
Ambos aumentan la variable i en uno. Es como decir i = i + 1. La diferencia es sutil.Si se está usando en un circuito como este, no hay diferencia:
for (int i = 0; i < 100; i++) {
}
for (int i = 0; i < 100; ++i) {
}
Si desea saber la diferencia, mira este ejemplo:
int a = 0;
int b = a++; // b = 0; a = 1
a = 0;
b = ++a: // b = 1; a = 1
La idea es que ++a incrementos a y devuelve ese valor, mientras que a++ devuelve el valor de a y luego incrementa a.
Aquí es una clase de muestra:
public class Increment
{
public static void main(String [] args)
{
for (int i = 0; i < args.length; ++i)
{
System.out.println(args[i]);
}
}
}
Si Puedo desmontar esta clase mediante javap.exe me sale esto:
Compiled from "Increment.java"
public class Increment extends java.lang.Object{
public Increment();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: iconst_0
1: istore_1
2: iload_1
3: aload_0
4: arraylength
5: if_icmpge 23
8: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
11: aload_0
12: iload_1
13: aaload
14: invokevirtual #3; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
17: iinc 1, 1
20: goto 2
23: return
}
Si cambio el bucle por lo que utiliza i ++ y desmontar de nuevo consigo esto:
Compiled from "Increment.java"
public class Increment extends java.lang.Object{
public Increment();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: iconst_0
1: istore_1
2: iload_1
3: aload_0
4: arraylength
5: if_icmpge 23
8: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
11: aload_0
12: iload_1
13: aaload
14: invokevirtual #3; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
17: iinc 1, 1
20: goto 2
23: return
}
Cuando comparo los dos, TextPad me dice que los dos son idénticos.
Lo que esto dice es que desde el punto de vista del código de bytes generado no hay diferencia en un bucle. En otros contextos, existe una diferencia entre ++ iy i ++, pero no para los bucles.
+1 por ir más allá. – paxdiablo
No es el ciclo lo que lo está haciendo, es el hecho de que no está en un contexto de expresión más amplio. Si su expresión del extremo del bucle fue más complicada, podría hacer una gran diferencia. –
Agregaré más al ejemplo de bucle y volveré a intentar ver. – duffymo
se procesa el modo de bucle es el siguiente
1 En primer lugar, se realiza la inicialización (i = 0)
2 se lleva a cabo la comprobación de (i < n)
3 el código en el bucle se ejecuta.
4 el valor se incrementa
5 Repita los pasos de 2 - 4
Esta es la razón por la cual, no hay diferencia entre i ++ y ++ i en el bucle que se ha utilizado.
Esta fue la respuesta que estaba buscando. ¡Gracias! – Chris
JLS§14.14.1, The basic for Statement, deja claro que el forUpdate expresión (s) son evaluados y el valor (s) están descarta. El efecto es hacer que las dos formas sean idénticas en el contexto de una declaración for.
Muchas instancias existentes. Respuesta corta: para tipos nativos nada. http://stackoverflow.com/questions/484462/difference-between-i-and-i-in-a-loop http://stackoverflow.com/questions/1941391/java-to-i-or-i-and -whats-the-difference-closed y muchos otros tomados de http://stackoverflow.com/search?q=i%2B%2B+%2B%2Bi – dmckee
relacionado: http://stackoverflow.com/questions/1756015/whats -the-difference-between-i-and-i-in-php – jldupont
++ debería ser más eficiente en teoría ya que i ++ simplemente a ++ iy una copia (para guardar el valor anterior) Pero supongo que JVM optimizará el último en un bucle for (al menos cualquier compilador lo haría ...) -> sin diferencia – user3063349