Arquivo Discussoes de Programacao e Tecnologia 
Por que não altera o y quando altero o x? as duas variaveis não esta referenciando o mesmo lugar na memória?
public static void main(String[] args){
Integer x = 400;
Integer y = x;
x++;
StringBuilder sb1 = new StringBuilder("123");
StringBuilder sb2 = sb1;
sb1.append("5");
System.out.println((x == y) + " " + (sb1 == sb2));
}
abraço
Integer x = 400;
Integer y = x; //referencia de x para y é igual a 400
x++; //vai acrescentar 1 para o x , portanto x passa a ser 401
x == y // 401 = 400 ==> false ou não ...
mas se y esta apontando para o mesmo lugar na memoria de x, pq quando altero o x não altera o y também?
giselezr, os wrappers não geram uma referência na memória. Elas apenas “embrulham” os valores primitivos para se comportarem como se fossem objetos. Portanto, quando você faz
Integer y = x;
Você copia o valor de x para y que está “embrulhado” como um objeto. Por isso que, ao fazer a comparação de valores, eles são diferentes após o pós-incremento.
hum… entendi 
obrigada
Isso se pede em exames de certificação? De qualquer forma, o que está escrito aqui “por debaixo dos panos” é:
Integer x = Integer.valueOf (400);
Integer y = x;
x = Integer.valueOf (x.intValue() + 1);
e, mais por debaixo dos panos ainda, Integer.valueOf(i) retorna um objeto Integer, obtido de um vetor de Integer criado durante a inicialização do programa, se -128 <= i <= +127, e um novo Integer se o valor for menor que -128 ou maior que +127.
Ou seja, é equivalente a:
Integer x = new Integer (400);
Integer y = x;
x = new Integer (401);
E é por isso que na hora de imprimir os valores de x e y, aparece como 401 e 400 respectivamente, e que x == y imprime “false”.
giselezr, os wrappers não geram uma referência na memória. Elas apenas “embrulham” os valores primitivos para se comportarem como se fossem objetos. Portanto, quando você fazInteger y = x;Você copia o valor de x para y que está “embrulhado” como um objeto. Por isso que, ao fazer a comparação de valores, eles são diferentes após o pós-incremento.
Hum… é mais ou menos isso, mas a explicação ainda não está certa. Como sempre, a realidade é mais complicada que parece 
A grosso modo, é como eu disse. Uma cópia. A grosso modo rs. Eu só não sabia como que o Java fazia isso especificamente por debaixo dos panos.
Acho que tais questões (que exigem um certo conhecimento do que vai “por debaixo dos panos” para serem corretamente respondidas) não deveriam cair. O problema é que alguns simulados têm tais questões.
Na verdade, os tipos wrappers comportam-se exatamente como quaisquer outros objetos. Ou seja o código abaixo:
Integer x = 400;
Integer y = x;
cria exatamente 1 objeto, e a atribuição y = x faz com que as duas variáveis apontem para exatamente o mesmo objeto na memória.
O truque nessa questão é ter em mente que objetos de tipos wrappers são imutáveis. Ou seja, uma vez que um objeto do tipo Integer encapsula um determinado valor inteiro, ele carregará esse valor por toda a vida; Se por um acaso você somá-lo com algum outro número ou incrementá-lo você vai obter um novo objeto. Sendo assim, no código
Integer x = 400;
Integer y = x;
x++
a linha x++ cria um novo objeto, e x passa apontar para esse novo objeto. Por sua vez, y continuará apontando para o antigo valor de x, uma referência para o objeto Integer 400.
Ah!!! Não imaginava que elas se comportavam como a String!!!
concordo com as explicações , mas para memorizar isto acho meio simples, pois penso assim:
Objeto imutável é o que não pode sofrer qualquer modificação em seu estado, depois de sua construção. A única forma de modificar um objeto contido por uma variável, é criar um novo e colocar no lugar do velho.
Integer é wrapper (começa com MAIÚSCULO) portanto imutável, até que se crie um novo para colocar no lugar do velho x++; … neste caso a referência foi feita a y pelo valor velho …