Arquivo Discussoes de Programacao e Tecnologia Byte b1 = new Byte("127");
if(b1.toString() == b1.toString())
System.out.println("true");
else
System.out.println("false");
eu naum entendi a resposta dessa. alguem sabe pq isso acontece. falow.
Muito simples, String é um objeto, logo não pode ser comparado com o operador ==, mas sim atraves de um metodo isEqual. para que o resultado saisse true, deveria ser o seguinte codigo:
Byte b1 = new Byte("127");
if (b1.toString().equals(b1.toString()))
System.out.println("true");
else
System.out.println("false");
mas b1 é só uma referencia a um objeto. e == naum compara essa referencia. estaria comparando ele com ele mesmo. pq isso é falso? valew.
então teria de ser b1==b1 e não b1.toString()==b1.toString()
OK, mas a comparacao que o java tá fazendo é o objeto que o metodo toString instancia e retorna (vc não vê mas isto acontece).
De qualquer forma se vc quisesse comparar o objeto b1, deveria ser algo do tipo
Byte b1 = new Byte("127");
Byte b2 = new Byte("127");
if (b1.equals(b2)) {
// vai entrar aqui ...
}
// ou ainda ...
if (b1.equals(b1)) {
// também entra aqui logicamente...
}
Daí sim, entraria no bloco do if
[]s, Welington B. Souza
entendi agora, toString() estancia um novo objeto cada vez q é chamada, por isso dá falso. Valew.
Ola pessoal , criei o seguinte codigo apartir desta discussão :
Bom conforme nosso amigo "wbsouza" falou :
OK, mas a comparacao que o java tá fazendo é o objeto que o metodo toString instancia e retorna (vc não vê mas isto acontece).
Eu nao entendi muito bem este "instanciar"...pois o que eu entendo é que todas as classes que são "descentendes" de Object e que não realizam um "overriding" de método possui o método toString() no seu conjunto de métodos, e que sempre que um objeto para fins de comparação e disponiblização(saída em tela..) o método toString() é executado implicitamente.
String nome;
System.out.println("Meu nome é " + nome);
é o mesmo que :
System.out.println("Meu nome é " + nome.toString());
Será que quando vc quiz dizer "instanciar" vc quis dizer isso ,ou existe algo mais ???
E quanto aos operadores que eu saída , eu posso utilizar o "==" para comparar referência de objetos e "equals" para comparar o conteúdo do chamado "CValue" (valor) de uma String!!!!!
Abaixo eu criei um código com as soluções propostas.......
as saídas do código foram :
------------------------------
"Cai no 1
Cai no 2
Cai no 3
Cai no 4
Cai no 6"
Abraço a todos.
public class TesteToString{
public static void main(String[] args) {
Byte b1 = new Byte("127");
Byte b2 = new Byte("127");
if (b1.equals(b2)) {
System.out.println("Cai no 1");
}
if (b1.equals(b1)) {
System.out.println("Cai no 2");
}
if (b1.toString().equals(b2.toString())) {
System.out.println("Cai no 3");
}
if (b1.toString().equals(b1.toString())) {
System.out.println("Cai no 4");
}
//------------------------------------------------------------
if (b1==b2) {
System.out.println("Cai no 5");
}
if (b1==b1) {
System.out.println("Cai no 6");
}
if (b1.toString()==b2.toString()) {
System.out.println("Cai no 7");
}
if (b1.toString()==b1.toString()) {
System.out.println("Cai no 9");
}
}
}
OK, vamos por partes.
Em partes vc tem razao, pois este metodo PODE para ser chamado de maneira implicita quando vc manda imprimir ou concatenar com uma string. Mas …
Mas o metodo toString() não pode ser usado para comparação entre objetos, pois vc pode ter dois objetos que tem a mesma saída em toString (como o String por exemplo, ou outra classe que vc sobrepoe o toString), no entanto, “apontarem” para endereços diferentes de memória (java não tem ponteiros, mas para facilitar o entendimento esta expressão é válida).
Primeiro, string em Java é uma classe, correto ?
Imagino que o return do toString em Object deva ser algo do tipo
{
String retorno = getNomeClasse() + getEnderecoMemoria() + getAgloMais();
return retorno;
}
Assim, implicitamente; está sendo instanciado um objeto baseado na classe String toda vez que vc chama o metodo toString. É exatamente por isso que quando vc compara b1.toString() == b2.toString(), este teste é falso, ou seja, apontam para referencias de objetos diferentes.
O fato de vc não precisar chamar o metodo toString para concatenar, com uma string ou imprimir o objeto é uma facilidade do java, ou seja, trata-se de uma sobrecarga do operador “+” e de um “overriding” de metodo no caso de um
System.out.println(myObject);
Vamos analisar melhor o seu codigo …
public class TesteToString{
public static void main(String[] args) {
Byte b1 = new Byte("127");
Byte b2 = new Byte("127");
// Quando vc invoca o metodo equals,
// a classe avalia as variaveis internas do objeto, como são
// identicas, pois foi executado apenas o construtor de forma
// identica, vai imprimir o "Cai no 1" ...
if (b1.equals(b2)) {
System.out.println("Cai no 1");
}
// este é bem obvio que o equals será verdadeiro, pois
// compara a mesma referencia de objeto
// logo, tb vai imprimir "Cai no 2" ...
if (b1.equals(b1)) {
System.out.println("Cai no 2");
}
// aqui tb vai ser verdadeiro, pois mesmo que seja alocado
// uma nova instancia para cada invocação do metodo toString,
// vc está usando o equals, que compara o "conteudo das
// variaveis internas do objeto". Assim
// tb será impresso "Caí no 3"
if (b1.toString().equals(b2.toString())) {
System.out.println("Cai no 3");
}
// nao precisa falar que tb ira imprimir, pois
// é a mesma referencia de objeto, assim
// tb será impresso
if (b1.toString().equals(b1.toString())) {
System.out.println("Cai no 4");
}
//------------------------------------------------------------
// nao ira imprimir, pois o operador == compara se
// as referencias de objetos se tratam das mesmas.
// Neste caso não é, assim, não será impresso
if (b1==b2) {
System.out.println("Cai no 5");
}
// será impresso, pois se trata da mesma referencia de
// objeto. Logo imprimirá "Caí no 6"
if (b1==b1) {
System.out.println("Cai no 6");
}
// tb nao será impresso, pois cada chamada no metodo toString
// retorna uma referencia de objeto. Assim, mesmo que tenham
// o conteudo igual, a expressão abaixo não será verdadeira,
// pois o operador == compara se os operandos se tratam da
// mesma referencia.
if (b1.toString()==b2.toString()) {
System.out.println("Cai no 7");
}
// também não retornará verdadeiro, pois como disse anteriormente
// cada chamada no metodo toString instanciará um objeto do tipo
// string. Logo são referencias diferentes. e volto a dizer novamente
// o operador == compara se os operandos se tratam da mesma
// referencia de objeto. Como não são a mesma referencia de objeto
// tb não será impresso
if (b1.toString()==b1.toString()) {
System.out.println("Cai no 9");
}
}
}
Espero que tenha sido claro o suficiente.
[]s, Welington B. Souza
Corrigindo, no System.out.println(obj), o objeto out tem um metodo sobrecarregado (overloading), ou seja o metodo com o mesmo nome, mas com assinaturas diferentes (quantidade de parametros e tipos de dados dos parametros).
[]s, Welington B. Souza