Qual é a diferença entre “.equals” e “==”? [duplicado]

Question

Esta questão já tem uma resposta aqui:

• Qual é a diferença entre == e equals () em Java? 23 respostas

Troquei professores hoje e afirmou através de um código estranho para mim. (Ele disse que é melhor usar .equals e quando eu perguntei por que, ele respondeu: "porque é!")

Então, aqui está um exemplo:

if (o1.equals(o2))
{
 System.out.println("Both integer objects are the same");
}

Em vez do que eu estou acostumado a:

if (o1 == o2)
{
  System.out.println("Both integer objects are the same");
}

Qual é a diferença entre os dois. E por que é a sua maneira (usando .equals) melhor?

Encontrei este em um procurar rápido, mas eu realmente não posso fazer o sentido de que a resposta:

Answer 1

Em Java, == sempre apenas compara duas referências (para não-primitivos, que é) -. Ou seja, ele testa se os dois operandos se referir ao mesmo objeto

No entanto, o método equals pode ser substituído -. Assim, dois objetos distintos ainda pode ser igual

Por exemplo:

String x = "hello";
String y = new String(new char[] { 'h', 'e', 'l', 'l', 'o' });

System.out.println(x == y); // false
System.out.println(x.equals(y)); // true

Além disso, vale a pena estar ciente de que quaisquer dois iguais constantes string (principalmente strings literais, mas também combinações de constantes string via concatenação) vai acabar se referindo à mesma cadeia. Por exemplo:

String x = "hello";
String y = "he" + "llo";
System.out.println(x == y); // true!

Aqui x e y são referências para a mesma cadeia, porque y é uma constante de tempo de compilação igual a "hello".

Answer 2

O operador == compara se os objetos são os mesmos instância . Os equals () oerator compara o estado dos objetos (por exemplo, se todos os atributos são iguais). Você pode até mesmo substituir os métodos equals () para definir a si mesmo quando um objeto é igual a outro.

Answer 3

Se você e eu cada caminhada para o banco, cada conta de novo uma marca aberta, e cada um depósito de US $ 100, então ...

1. myAccount.equals(yourAccount) é true porque eles têm o mesmo valor , mas
2. myAccount == yourAccount é false porque eles não são o mesma conta .

(Assumindo definições apropriadas da classe Account, é claro; -).

Answer 4

== é um operador. é igual a é um método definido na classe de objeto

== verifica se dois objetos têm o mesmo endereço na memória e para ele verifica primitivos se eles têm o método mesmas value.equals nas outras verificações manuais se os dois objetos que estão sendo comparados têm um valor igual (dependendo como é claro o é igual a método foi implementado para os objetos. iguala método não pode ser aplicado em primitivas (o que significa que se A é um a.Equals primitivas (SomeObject) não é permitida, no entanto someobject.equals (a) é permitido).

Answer 5

== operador compara duas referências de objeto para verificar se eles se referem a mesma instância. Isso também, retornará true no exemplo match.for sucesso

public class Example{
public static void main(String[] args){
String s1 = "Java";
String s2 = "Java";
String s3 = new string ("Java");
test(Sl == s2)     //true
test(s1 == s3)      //false
}}

== acima exemplo é uma comparação de referência isto é, tanto objectos apontam para a mesma posição de memória

string é igual a () é avalia para a comparação dos valores nos objetos.

   public class EqualsExample1{
   public static void main(String args[]){
   String s = "Hell";
   String s1 =new string( "Hello");
   String s2 =new string( "Hello");
   s1.equals(s2);    //true
    s.equals(s1) ;   //false
    }}

exemplo acima Ele compara o conteúdo das cordas. Ele irá retornar verdadeiro se jogos de cordas, senão retorna falso.

Answer 6

Em Java, quando o “==” operador é usado para comparar 2 objetos, ele verifica para ver se os objetos se referem ao mesmo lugar na memória. EX:

String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1 == obj2)
   System.out.println("obj1==obj2 is TRUE");
else
  System.out.println("obj1==obj2 is FALSE");

Mesmo que as cordas têm os mesmos caracteres exatas ( “xyz”), O código acima irá realmente de saída: obj1 == obj2 é FALSE

classe Java string realmente substitui o padrão equals () implementação na classe Object - e substitui o método para que ele verifica apenas os valores das cordas, não suas posições na memória. Isto significa que se você chamar o método equals () para comparar 2 objetos String, então, enquanto a sequência real de caracteres é igual, os dois objetos são considerados iguais.

String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1.equals(obj2))
   System.out.printlln("obj1==obj2 is TRUE");
else
  System.out.println("obj1==obj2 is FALSE");

A saída será de código a seguir:

obj1 == obj2 é TRUE

Answer 7

public static void main(String[] args){
        String s1 = new String("hello");
        String s2 = new String("hello");

        System.out.println(s1.equals(s2));
        ////
        System.out.println(s1 == s2);

    System.out.println("-----------------------------");

        String s3 = "hello";
        String s4 = "hello";

        System.out.println(s3.equals(s4));
        ////
        System.out.println(s3 == s4);
    }

Aqui neste código u pode campare a ambos '==' e' .equals'

aqui .Equals é usado para comparar os objetos de referência e '==' é usado para comparar estado de objetos ..

Answer 8

(1) pode ser == ser aplicada para ambos os primitivos e tipos de objectos, mas iguais () método pode ser aplicado apenas para tipos de objectos.

(2) == não pode ser substituído para a comparação de conteúdo, mas é igual a método pode ser substituído para a comparação de conteúdo. (Ex; classe String, classes de mensagens publicitárias, classes de coleção)

(3) == dá tipos incomparáveis ??de erro ao tentar aplicar para tipos heterogêneos, onde como iguais método retorna falso.

Answer 9

O método equals( ) eo operador == realizar duas operações diferentes. O método equals( ) compara os caracteres dentro de um objecto String. O operador == compara duas referências de objeto para ver se eles se referem à mesma instância. Os seguintes programa mostra como dois objetos String diferentes podem conter os mesmos personagens, mas as referências a esses objetos não são considerados iguais:

// equals() vs ==
class EqualsNotEqualTo {
     public static void main(String args[]) {
          String s1 = "Hello";
          String s2 = new String(s1);
          System.out.println(s1 + " equals " + s2 + " -> " +
          s1.equals(s2));
          System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));
     }
}

O s1 variável refere-se à ocorrência de String criado por “Hello”. O objeto referido por s2 é criado com s1 como um inicializador. Assim, os conteúdos dos dois objectos de corda são idênticos, mas eles são objetos distintos. Isto significa que s1 e s2 não se referem aos mesmos objetos e são, por conseguinte, não ==, como é mostrado aqui pela saída do exemplo anterior:

Hello equals Hello -> true
Hello == Hello -> false

Answer 10

Vamos dizer que "==" operador retorna verdadeiro se ambos os dois operandos pertencem ao mesmo objeto, mas quando ele vai retornar true como não podemos atribuir um único objeto vários valores

public static void main(String [] args){
    String s1 = "Hello";
    String s1 = "Hello";  // This is not possible to assign multiple values to single object
    if(s1 == s1){
      // Now this retruns true
   }
}

Agora, quando isso acontece, em termos práticos, se a sua não acontecer, então por que isso é == compara funcionalidade ....

Answer 11

Aqui está uma interpretação simples sobre o seu problema:

== (igual a) utilizado para avaliar a expressão aritmética

onde como

é igual a () método utilizado para comparar corda

Por isso, é melhor usar == para operações e iguais numéricos () método para operações relacionadas cadeia. Assim, para a comparação de objetos os equals () método seria escolha certa.