Operadores em java,Prioridade de Operadores, Pré/Pos Incremento/Decremento

Quais são os Operadores em java?
Source: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/opsummary.html

Simple Assignment Operator

= Simple assignment operator

Arithmetic Operators

+ Additive operator (also used for String concatenation)
- Subtraction operator
* Multiplication operator
/ Division operator
% Remainder operator

Unary Operators

+ Unary plus operator; indicates positive value (numbers are positive without this, however)
- Unary minus operator; negates an expression
++ Increment operator; increments a value by 1
-- Decrement operator; decrements a value by 1
! Logical compliment operator; inverts the value of a boolean

Equality and Relational Operators

== Equal to
!= Not equal to
> Greater than
>= Greater than or equal to
< style="font-weight: bold;">Conditional Operators

Condition Operators

&& Conditional-AND
|| Conditional-OR
?: Ternary (shorthand for if-then-else statement)

Type Comparison Operator

instanceof Compares an object to a specified type

Bitwise and Bit Shift Operators

~ Unary bitwise complement
<<>> Signed right shift
>>> Unsigned right shift
& Bitwise AND
^ Bitwise exclusive OR
| Bitwise inclusive OR


Precedência de Operadores em java:
Source: http://www.uni-bonn.de/~manfear/javaoperators.php

Prioridade

Operador

Operação

1	[ ]	array index
	( )	method call
	.	member access - 1
2	++	pre- or postfix increment
	--	pre- or postfix decrement
	+ -	unary plus, minus
	~	bitwise NOT
	!	boolean (logical) NOT
	(type)	type cast
	new	object creation - 2
3	* / %	multiplication, division, remainder
4	+ -	addition, substraction
	+	string concatenation -4
5	<<	signed bit shift left
	>>	signed bit shift right
	>>>	unsigned bit shift right - 5
6	< <=	less than, less than or equal to
	> >=	greater than, greater than or equal to
	instanceof	reference test - 6
7	==	equal to
	!=	not equal to
8	&	bitwise AND
	&	boolean (logical) AND
9	^	bitwise XOR
	^	boolean (logical) XOR
10	|	bitwise OR
	|	boolean (logical) OR
11	&&	boolean (logical) AND
12	||	boolean (logical) OR
13	? :	conditional - 13
14	=	assignment
	*= /= += -= %= <<= >>= >>>= &= ^= |=	combinated assignment (operation and assignment)

Oque tudo isso significa?
Que a precedência de Operadores é IMPORTANTE, pois dependendo muda o resultado.

int c = 25 - 5 * 4 / 2 - 10 + 4; c aqui recebe 34

int c = 25 - ((5 * 4) /2)) - 10 + 4; c aqui recebe 9


Quero abrir um espaço para falando Somente sobre o Operador de Incremento e Decremento(++ e --):
- Quando estão sozinhos, eles são a mesma coisa que acrescentar 1 Porem:

Pré Incremento: Incrementa quando aparece o operador
Pós Incremento: Incrementa somente na Instrução de baixo

Pré Decremento: Decrementa quando aparece o operador
Pós Decremento: Decrementa somente na Instrução de baixo

Exemplo:

int b = 2;
++b; // Pré Incremento , b = 3

int b = 2;
b++; //Pos Incremento, b = 2
int a = b; //Aqui o b vale 3

Mesma coisa com Decremento.


AGORA QUANDO ELE são usados com algum Operador, a coisa muda.

int b = 2;
int c = ++b;// b = 3, c = 3.


int b = 2;
int c = b++;// c = 2, b =3(Somente na proxima Instrução)
Proxima Instrução

Explicando oque aconteceu:

Em:

int b = 2;
int c = ++b;

Temos em bytecode:

0: iconst_2
1: istore_1
2: iinc 1, 1
5: iload_1
6: istore_2
*As explicações estão no tutorial: Básico sobre bytecodes

Suponto que estamos usando o método main, veremos oque ocorre no Frame, Lembre-se que o index 0 da local variable é uma Referência a Constant Pool

0: iconst_2:

Clique na imagem para ampliar


1: istore_1


Clique na imagem para ampliar

2: iinc 1, 1


Clique na imagem para ampliar

5: iload_1


Clique na imagem para ampliar

6: istore_2


Clique na imagem para ampliar

Sendo b index 1 da Local Variable, c index 2 da Local Variable, temos b e c com o valor de 3.


Veremos o próximo:

int b = 2;
int c = b++;

Temos em Bytecode:

0: iconst_2
1: istore_1
2: iload_1
3: iinc 1, 1
6: istore_2
0: iconst_2:



1: istore_1



2: iload_1


3: iinc 1, 1



6: istore_2



Sendo b index 1 da Local Variable, c index 2 da Local Variable, temos b = 3 e c com o valor de 2.



E se tivermos mais de um operador Unário?

int b = 3;
int c = b++ + 1;

Vamos em ordem de Precedência de Operadores:
1 - Primeiro Operador de Pos Incremento:
c = 3 + 1 = 4;
b = 4;


Outro Exemplo:

int b = 2;
int c = b++ + ++b;
Vamos em ordem de Precedência de Operadores:

1 - Primeiro Operador de Pos Incremento:
int c = 2 + ++b; -> Aqui quando ele carrega o b, ele ja tem o valor de 3
pois ja é a próxima instrução
b = 3;(na Próxima instrução)

2 - Primeiro Operador de Pos Incremento:
int c = 2 + 4 = 6
b = 4;


Em bytecode Temos: Sendo b index 1, c index 2 da Local Variable

Code:
0: iconst_2
1: istore_1
2: iload_1
3: iinc 1, 1
6: iinc 1, 1
9: iload_1
10: iadd
11: istore_2

0: iconst_2



1: istore_1


2: iload_1



3: iinc 1, 1



6: iinc 1, 1


9: iload_1


10: iadd



11: istore_2



Curiosidade:
O Operador % remain é chamado MOD.

Exemplo:
2 % 2 = 0 pois a conta é exata
3 % 2 = 1 pois para a conta dar certa so posso ir ate o 2
1 % 2 = 1 quando é menor é sempre ele mesmo



Bom basicamente era essa a intenção, Próximo Post, cast,Promoção em tipos primitivos.
Cya DUDES!