Operadores "+=" e "-="

x += y significa x = x + y;
O mesmo para os outros sinais.

Serve apenas para “simplificar”.

Recomendo utilizar x = x+y ao invés do x+=y. É mais legível.

aah blz!
vlw ai cara
abraço

Felipe.

Quando aprendi Java, meu professor disse que o modo simplificado é um pouquinho mais rápido. Mas realmente, é importante fazer o código ficar legível.

aah blz!
vlw ai cara
abraço

Felipe.

aah blz!
vlw ai cara
abraço

Felipe.

Lembrando que com esses operadores aconteçe um cast automático.
por exemplo:
byte b=1, y=1;
b= b+y; //essa parte da erro, pq gera um int, e byte nao armazena um int.

mas se utilizar o operador += ou algum similar, o código compila.

joca_java:

Serve apenas para “simplificar”.

Recomendo utilizar x = x+y ao invés do x+=y. É mais legível.

[]'s.

gugaa_df:

Lembrando que com esses operadores aconteçe um cast automático.
por exemplo:
byte b=1, y=1;
b= b+y; //essa parte da erro, pq gera um int, e byte nao armazena um int.

mas se utilizar o operador += ou algum similar, o código compila.

Belo comentário, cara. Quase ninguém sabe ou se lembra disso.

kaique:

joca_java:

Serve apenas para “simplificar”.

Recomendo utilizar x = x+y ao invés do x+=y. É mais legível.

Mas essa notação é mas otimizada, tendo um desempenho maior. Isso é muito utilizado em sistemas que funcionam em dispositivos limitados.

[]'s.

Aí vem a minha dúvida: como uma operação com cast pode ser mais rápida do que uma sem cast? Pela lógica, uma operação dessa pode ser, no máximo, tão rápida quanto uma normal, ou seja:

// operação 1
i = (int) (i + 10);

// operação 2
i += 10;

As operações 1 e 2 são idênticas.

Outra dúvida que surge: nunca vi nenhuma recomendação sobre preferir o += (ou variantes) à outra maneira de atribuir valores a variáveis. Se realmente for mais rápido, não deveria haver uma recomendação da Sun ou algo assim?

São só dúvidas críticas que eu tenho, não sei se estão certas. Mas não faz sentido?

felipealbuquerque:

gugaa_df:

Lembrando que com esses operadores aconteçe um cast automático.
por exemplo:
byte b=1, y=1;
b= b+y; //essa parte da erro, pq gera um int, e byte nao armazena um int.

mas se utilizar o operador += ou algum similar, o código compila.

Belo comentário, cara. Quase ninguém sabe ou se lembra disso.

kaique:

joca_java:

Serve apenas para “simplificar”.

Recomendo utilizar x = x+y ao invés do x+=y. É mais legível.

Mas essa notação é mas otimizada, tendo um desempenho maior. Isso é muito utilizado em sistemas que funcionam em dispositivos limitados.

[]'s.

Aí vem a minha dúvida: como uma operação com cast pode ser mais rápida do que uma sem cast? Pela lógica, uma operação dessa pode ser, no máximo, tão rápida quanto uma normal, ou seja:

// operação 1
i = (int) (i + 10);

// operação 2
i += 10;

As operações 1 e 2 são idênticas.

Outra dúvida que surge: nunca vi nenhuma recomendação sobre preferir o += (ou variantes) à outra maneira de atribuir valores a variáveis. Se realmente for mais rápido, não deveria haver uma recomendação da Sun ou algo assim?

São só dúvidas críticas que eu tenho, não sei se estão certas. Mas não faz sentido?

Penso, que as duas tem o mesmo desempenho. só que uma o cast é explicito e na outra nao. mas por tras ocorre a mesma coisa…

É a minha opinião também.

Tenho cá minhas dúvidas, pois como dois códigos iguais (sim, iguais) geram desempenhos diferentes?
Exemplo de código:

--Teste.java public class Teste{ public static void main(String args[]){ int i = 0; int z = 1; int a = 0; System.out.println("Iniciando"); a +=z; System.out.println("Primeira saída: "+a); i = i +z; System.out.println("Segunda saída: "+i); } }
Depois de javac Teste.java, executamos o código ( java Teste ) temos o seguinte resultado:

Iniciando Primeira saída: 1 Segunda saída: 1
Até aí, nada de novo. Agora que vem a grande jogada. Porque vocês não tentam verificar esse código com o Java File Disassembler ( javap )? O comando para esse teste é javap -v Teste. Agora analisem o fim da saída:

(...)
public static void main(java.lang.String[]);
  Code:
   Stack=3, Locals=4, Args_size=1
   0:   iconst_0  
   1:   istore_1  //alocando a primeira variavel
   2:   iconst_1
   3:   istore_2  //alocando a segunda variável
   4:   iconst_0
   5:   istore_3 //alocando a terceira variável
   6:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   9:   ldc     #3; //String Iniciando
   11:  invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   14:  iload_3  //carregando a terceira ( a ) 
   15:  iload_2  //carregando a segunda ( z )
   16:  iadd      //somando
   17:  istore_3  //guardando o resultado em ( a )
   18:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   21:  new     #5; //class java/lang/StringBuilder
   24:  dup
   25:  invokespecial   #6; //Method java/lang/StringBuilder."<init>":()V
   28:  ldc     #7; //String Primeira saída:
   30:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   33:  iload_3
   34:  invokevirtual   #9; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   37:  invokevirtual   #10; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   40:  invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   43:  iload_1 // carregando a primeira ( i )
   44:  iload_2 // carregando a segunda ( z )
   45:  iadd     //somando
   46:  istore_1  //guardando o resultado em ( i )
   47:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   50:  new     #5; //class java/lang/StringBuilder
   53:  dup
   54:  invokespecial   #6; //Method java/lang/StringBuilder."<init>":()V
   57:  ldc     #11; //String Segunda saída:
   59:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   62:  iload_1
   63:  invokevirtual   #9; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   66:  invokevirtual   #10; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   69:  invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   72:  return
  LineNumberTable:
   line 3: 0
   line 4: 2
   line 5: 4
   line 6: 6
   line 7: 14
   line 8: 18
   line 9: 43
   line 10: 47
   line 11: 72


}

Agora como podem ter desempenhos diferentes se geram o mesmo código no final?

Até!

Não estou em casa, mas creio que para matar a dúvida, podemos contas o tempo gasto para, seilah, 200 operações com as 2 situações, utilizando umas 10 casas decimais… Se ninguém fizer o teste, eu farei chegando em casa…

Vais qualificar até quantos nanossegundos de diferença? Pois esse número de operações e tamanho é ínfimo para testar algo. Para se ter comparações, deveriam ser milhões de operações para dar diferença significativa, que eu ainda afirmo, tem performance igual.

Até!