String pool, referência de Strings

retorna falso pq a referencia eh para outro objeto que por acaso tem uma referencia semelhante a anterior. para ser true ai somente usando equals…

flw! feliz ano novo!

Exato. O operador == compara o padrão de bits de cada referência. No caso, cada referência aponta para um objeto diferente, logo o padrão de bits de cada uma delas é diferente.

Djonatah:

Alguém poderia me explicar porque o código abaixo retorna falso, desde que pela definição há apenas um objeto na String pool?

String s1 = "ABC";
String s2 = "ABC";
System.out.println(s1==s2); // deveriam referenciar para o mesmo objeto, ou não?

Obrigado
Abraços

<><

Realmente deveria ter retornado true. Segue um texto que explica isso em detalhes:

http://www.xyzws.com/javafaq/what-is-string-literal-pool/3

A JVM que você está usando é a da Sun?

Pode ser que pelo motivo do seu código ser bem simples, na hora de compilar, o compilador abriu mão do String Pool, mas não
sei se é isso.

Se alguém souber dar uma resposta precisa!

PS: Pelo que eu entendi, o nosso amigo sabe que pra comparar String ele deve usar o equals, o que ele está querendo entender
é porque o String pool não foi usado no caso dele…

[]s

lach

Exatamente colega
não sei porque…como eu posso saber se minah JVM é da Sun? (eu ó consegui achar a version dela )

Espero mais comentários.

Abraços

rod.attack, eu quis dizer que SE existe apenas uma string na minha string pool as referências teriam que ter o mesmo bit pattern, pois se existe apenas um objeto como pode as referências divergirem?

espero que não lhe confundi

Abraços e um feliz ano novo \o/

Sim, sim, desculpe pela confusão. Quando achar a resposta não deixe de postar.

Para mim, como esperado, sempre retorna true, nao importa se compilando com o compilador do Eclipse, ou JDK 1.5, ou 1.6.

Qual o compilador que tu usas?

E o teu código de teste é exatamente como tu mostraste? Se estiveres usando constantes, bom, aí as coisas são um pouco diferentes.

Hmmm eu fiz uns testes aqui no trabalho e retornou true tbm

Bom, eu tenho rodado os examples (em casa) por uma IDE (JCreator), e não sei qual JVM ela etá usando…

Vou chegar em casa e fazer o teste pela IDE.

Obrigado.

<><

Djonatah:

Alguém poderia me explicar porque o código abaixo retorna falso, desde que pela definição há apenas um objeto na String pool?

Aqui retorna true…

olá pessoal,

Caramba !!! vcs querem fazer confusão na minha cabeça justo agora…faltndo 1 semana para minha SCJP.

Eu tenho “quase” absoluta certeza q é TRUE o resultado…

Pelo fato q vc ta simplesmente adicionando um literal no pool de String…

entaum quando vc atribui o primeiro, no caso s1, vc vai estar colocando “ABC” no pool.

na próxima atribuição, no caso s2, ele vai ver c ta no pool para economizar memória para não precisar alocar outro objeto.

dai s1 e s2 vão referenciar o msm objeto.

Agora c vcs me falarem q isso é FALSE… eu vou ficar maluko hein…kkkkkkkk

Ricardo

Pessoal,

Desculpe a confusão, acabei de descobrir que foi um problema operacional MEU

O código acima realmente retorna TRUE. O que eu estava tentando fazer e que retornava FALSE era o seguinte:

String a = "ABC";
String b = "ABC";
System.out.println("a==b >> " + a==b); // isso realmente retorna false

Eu não sei o porque ainda, estou tentando descobrir. tenho das sugetões.
1 - O modo que o método println() avalia o argumento
2 - Precendência de operador

CONCLUSÃO
O código do primeiro pos retorna TRUE
mas cuidado com o println ;D

Obrigado pelos posts, e desculpe-me pela confusão

Abraços
<><

Ordem dos operadores:

String a = "ABC";
		String b = "ABC";
		System.out.println(s1==s2);
		System.out.println("A==B >> " + a==b); // imprime FALSE
		System.out.println("A==B >> " + (a==b)); // imprime "A==B >> true"
		System.out.println(("A==B >> " + a)==b); // imprime FALSE

Nota que isso não tem nada a ver com o PrintStream#println, que é um método como todos os outros em Java. As regras para avaliação de expressões são sempre as mesmas independente do contexto em que elas aparecem (inicializando uma variável ou como argumento para um invocação de método).