strings - string[] java

Diferencia entre a+= 10 y a=a+10 en java?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Por qué los operadores de asignación de compuestos + =, - =, * =, / = de Java no requieren conversión? 10 respuestas

¿Son a += 10 y a = a + 10 ambos iguales, o hay alguna diferencia entre ellos? Obtuve esta pregunta mientras estudiaba tareas en Java.

Answer 1

Como ya mencionó el casting ... hay una diferencia en este caso:

byte a = 5;
a += 10; // Valid
a = a + 10; // Invalid, as the expression "a + 10" is of type int

De la especificación de lenguaje de Java sección 15.26.2 :

Una expresión de asignación compuesta de la forma E1 op= E2 es equivalente a E1 = (T)((E1) op (E2)) , donde T es el tipo de E1 , excepto que E1 se evalúa solo una vez.

Curiosamente, el ejemplo que dan en la especificación:

short x = 3;
x += 4.6;

es válido en Java, pero no en C # ... básicamente en C #, el compilador realiza mayúsculas / minúsculas especiales de + = y - = para garantizar que la expresión sea del tipo de destino o sea un literal dentro del rango del tipo de destino.

Answer 2

En las expresiones que muestra, son equivalentes, en una expresión como:

array[getIndex(context)][some / complex + expression] += offset;

obtienes una idea de en qué situaciones el operador + = (y los otros operadores de asignación) es útil. Si la expresión no es trivial, el operador + = evita errores y mejora la legibilidad y, por lo tanto, la capacidad de mantenimiento.

Answer 3

Esto se define en la Especificación del lenguaje Java, sección 15.25.2 . La parte más destacada es:

Una expresión de asignación compuesta de la forma E1 op = E2 es equivalente a E1 = (T) ((E1) op (E2)), donde T es el tipo de E1, excepto que E1 se evalúa solo una vez.

Es decir, en su caso, la diferencia es el tipo implícito:

byte a = 100;
a += 1000;    // compiles
a = a + 1000; // doesn''t compile, because an int cannot be assigned to a byte.

Answer 4

Hay algunas terminologías en el campo S / W, puedo explicarte esto,

en a=a+1 asignación para a se mide después de dos pasos

1. El sistema calcula el valor de a (se crea una nueva copia aislada aquí)
2. El sistema agrega 10 a la variable aislada a luego el valor de aislado a se asigna al lado izquierdo a

Pero en el segundo caso,

1. El sistema conoce el valor de a y agrega directamente 10 a a (no se ha realizado ninguna copia aislada aquí).

Espero que esto sea útil para usted, y una cosa más, generalmente usamos un método que es a += 10; porque reduce el costo de operación, como otros,

Answer 5

No hay diferencia, uno es taquigrafía para el otro. Incluso el compilador generará las mismas instrucciones para ambos.

Editar : el compilador NO genera el mismo código para ambos, como acabo de descubrir. Mira esto:

dan$ cat Test.java
public class Test {
    public static void main(String[] args) {
        int a = 0;
        a = a + 10;
        a += 20;
    }
}

dan$ javap -c Test
Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  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:   bipush  10
   5:   iadd
   6:   istore_1
   7:   iinc    1, 20
   10:  return

}

Así que la respuesta corta, especialmente para un principiante de Java, o para cualquiera que no esté preocupado por optimizar al más mínimo nivel, es que son intercambiables. La respuesta larga dependerá de mí leyendo sobre iadd vs iinc.

Editar 2 : Ok, estoy de vuelta. Las especificaciones de la instrucción son (aproximadamente) de la siguiente manera:

iadd : agrega los dos mejores en la pila

iinc : incrementa una variable local mediante una constante

Y como vimos anteriormente, podemos guardar un par de instrucciones usando iinc, siempre que haya una constante en el lado derecho.

Pero, ¿qué pasa si tenemos

a += a ?

Entonces el código se ve así:

   7:   iload_1
   8:   iload_1
   9:   iadd
   10:  istore_1

que es lo mismo que obtenemos si tenemos a = a + a .