objects - use equals java

String.equals contra==

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo comparo cadenas en Java? 23 respuestas

Este código separa una cadena en tokens y las almacena en una matriz de cadenas, y luego compara una variable con la primera casa ... ¿por qué no funciona?

public static void main(String...aArguments) throws IOException {

    String usuario = "Jorman";
    String password = "14988611";

    String strDatos = "Jorman 14988611";
    StringTokenizer tokens = new StringTokenizer(strDatos, " ");
    int nDatos = tokens.countTokens();
    String[] datos = new String[nDatos];
    int i = 0;

    while (tokens.hasMoreTokens()) {
        String str = tokens.nextToken();
        datos[i] = str;
        i++;
    }

    //System.out.println (usuario);

    if ((datos[0] == usuario)) {
        System.out.println("WORKING");
    }
}

Answer 1

Conoce a Jorman

Jorman es un exitoso hombre de negocios y tiene 2 casas.

Pero otros no lo saben.

¿Es el mismo Jorman?

Cuando le preguntas a los vecinos de Madison o Burke, esto es lo único que pueden decir:

Usando la residencia solo, es difícil confirmar que es el mismo Jorman. Ya que son 2 direcciones diferentes, es natural asumir que esas son 2 personas diferentes.

Así es como se comporta el operador == . Entonces dirá que los datos[0]==usuario son falsos, porque solo compara las direcciones .

Un investigador al rescate

¿Qué pasa si enviamos un investigador? Sabemos que es el mismo Jorman, pero tenemos que probarlo. Nuestro detective observará de cerca todos los aspectos físicos. Con una investigación exhaustiva, el agente podrá concluir si es la misma persona o no. Veamos que suceda en términos de Java.

Aquí está el código fuente del método equals() de String:

Compara las cadenas de caracteres por caracteres, para llegar a la conclusión de que son iguales.

Así es como se comporta el método String Equals. Entonces, los datos[0].equals(usuario) devolverán verdadero, porque realiza una comparación lógica .

Answer 2

@ Melkhiah66 Puedes usar el método igual en lugar del método ''=='' para verificar la igualdad. Si usa intern (), entonces verifica si el objeto está en el grupo, si está presente, y luego vuelve a ser desigual. El método Equals utiliza internamente el código hash y le proporciona el resultado requerido.

public class Demo
{
  public static void main(String[] args)
  {
              String str1 = "Jorman 14988611";
    String str2 = new StringBuffer("Jorman").append(" 14988611").toString();
    String str3 = str2.intern();
    System.out.println("str1 == str2 " + (str1 == str2));           //gives false
    System.out.println("str1 == str3 " + (str1 == str3));           //gives true
    System.out.println("str1 equals str2 " + (str1.equals(str2)));  //gives true
    System.out.println("str1 equals str3 " + (str1.equals(str3)));  //gives true
  }
}

Answer 3

Alguien dijo en una publicación más arriba que == se usa para int y para verificar nulos. También se puede usar para verificar operaciones booleanas y tipos de caracteres.

Sin embargo, tenga mucho cuidado y vuelva a comprobar que está utilizando un char y no un String. por ejemplo

    String strType = "a";
    char charType = ''a'';

para las cadenas, entonces marcarías Esto sería correcto

    if(strType.equals("a")
        do something

pero

    if(charType.equals(''a'')
        do something else

sería incorrecto, necesitarías hacer lo siguiente

    if(charType == ''a'')
         do something else

Answer 4

Analicemos el siguiente Java, para entender la identidad y la igualdad de las cuerdas:

public static void testEquality(){
    String str1 = "Hello world.";
    String str2 = "Hello world.";

    if (str1 == str2)
        System.out.print("str1 == str2/n");
    else
        System.out.print("str1 != str2/n");

    if(str1.equals(str2))
        System.out.print("str1 equals to str2/n");
    else
        System.out.print("str1 doesn''t equal to str2/n");

    String str3 = new String("Hello world.");
    String str4 = new String("Hello world.");

    if (str3 == str4)
        System.out.print("str3 == str4/n");
    else
        System.out.print("str3 != str4/n");

    if(str3.equals(str4))
        System.out.print("str3 equals to str4/n");
    else
        System.out.print("str3 doesn''t equal to str4/n");
}

Cuando la primera línea de código String str1 = "Hello world." se ejecuta, se crea una cadena /Hello world." , y la variable str1 refiere a ella. Otra cadena "Hello world." no se volverá a crear cuando la siguiente línea de código se ejecute debido a la optimización. La variable str2 también se refiere a existente ""Hello world." .

El operador == comprueba la identidad de dos objetos (si dos variables se refieren al mismo objeto). Como str1 y str2 refieren a la misma cadena en la memoria, son idénticos entre sí. El método equals igualdad de verificación de dos objetos (si dos objetos tienen el mismo contenido). Por supuesto, el contenido de str1 y str2 son los mismos.

Cuando el código String str3 = new String("Hello world.") ejecuta, una nueva instancia de string con el contenido "Hello world." es creado, y es referido por la variable str3 . Y luego otra instancia de cadena con contenido "Hello world." Se crea de nuevo, y se hace referencia por str4 . Como str3 y str4 refieren a dos instancias diferentes, no son idénticas, pero su contenido es igual.

Por lo tanto, la salida contiene cuatro líneas:

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

Answer 5

Debe usar la cadena igual para comparar dos cadenas para la igualdad, no el operador == que simplemente compara las referencias.

Answer 6

El operador == es una comparación simple de valores.
Para referencias de objeto, los (valores) son (referencias). Entonces x == y devuelve verdadero si x e y hacen referencia al mismo objeto.

Answer 7

En lugar de

datos[0] == usuario

utilizar

datos[0].equals(usuario)

== compara la referencia de la variable donde .equals() compara los valores que es lo que desea.

Answer 8

Es bueno notar que, en algunos casos, el uso del operador "==" puede llevar al resultado esperado, debido a la forma en que java maneja las cadenas - los literales de cadenas se internan (vea String.intern() ) durante la compilación - así que cuando escribe para ejemplifique "hello world" en dos clases y compare esas cadenas con "==" podría obtener el resultado: verdadero, que se espera según la specification ; cuando se comparan las mismas cadenas (si tienen el mismo valor) cuando la primera es literal de cadena (es decir, se define a través de "i am string literal" ) y la segunda se construye durante el tiempo de ejecución, es decir. con "new" keyword como new String("i am string literal") , el operador == (igualdad) devuelve false, porque ambos son instancias diferentes de la clase String .

La única manera correcta es usar .equals() -> datos[0].equals(usuario) . == dice solo si dos objetos son la misma instancia de objeto (es decir, tienen la misma dirección de memoria)

Actualización : 01.04.2013 Actualicé esta publicación debido a los comentarios a continuación, que de alguna manera son correctos. Originalmente declaré que interning (String.intern) es un efecto secundario de la optimización de JVM. Aunque ciertamente ahorra recursos de memoria (que era lo que entendía por "optimización") es principalmente una característica del lenguaje

Answer 9

Generalmente .equals se utiliza para la comparación de Object , donde desea verificar si dos Objects tienen un valor idéntico.

== para la comparación de referencia (son los dos Objects el mismo Object en el montón) y para verificar si el Object es nulo. También se utiliza para comparar los valores de los tipos primitivos.

Answer 10

Los .equals() comprobarán si las dos cadenas tienen el mismo valor y devolverán el valor boolean mientras que el operador == comprueba si las dos cadenas son el mismo objeto.

Answer 11

Sé que esta es una pregunta antigua, pero así es como la veo (me parece muy útil):

Explicaciones técnicas

En Java, todas las variables son tipos primitivos o referencias .

(Si necesita saber qué es una referencia: las "variables de objeto" son solo indicadores de objetos. Así que con Object something = ... , algo es realmente una dirección en la memoria (un número).)

== compara los valores exactos. Entonces compara si los valores primitivos son los mismos, o si las referencias (direcciones) son iguales. Es por eso que == menudo no funciona en Strings; Las cadenas son objetos, y hacer == en dos variables de cadena solo se compara si la dirección es la misma en la memoria, como han señalado otras. .equals() llama al método de comparación de objetos, que comparará los objetos reales señalados por las referencias. En el caso de las cadenas, compara cada carácter para ver si son iguales.

La parte interesante :

Entonces, ¿por qué == veces devuelve true para Strings? Tenga en cuenta que las cuerdas son inmutables. En tu código, si lo haces.

String foo = "hi";
String bar = "hi";

Como las cadenas son inmutables (cuando se llama .trim() o algo así, produce una cadena nueva, que no modifica el objeto original al que se apunta en la memoria), en realidad no se necesitan dos objetos String("hi") . Si el compilador es inteligente, el bytecode leerá para generar solo un objeto String("hi") . Así que si lo haces

if (foo == bar) ...

Justo después, están apuntando al mismo objeto y devolverán verdadero. Pero rara vez pretendes esto. En su lugar, está solicitando la entrada del usuario, que está creando nuevas cadenas en diferentes partes de la memoria, etc., etc.

Nota : Si haces algo como baz = new String(bar) el compilador todavía puede descubrir que son lo mismo. Pero el punto principal es que cuando el compilador ve cadenas literales, puede optimizar fácilmente las mismas cadenas.

No sé cómo funciona en tiempo de ejecución, pero asumo que la JVM no mantiene una lista de "cadenas en vivo" y verifico si existe una misma cadena. (p. ej., si lee una línea de entrada dos veces y el usuario ingresa la misma entrada dos veces, no verificará si la segunda cadena de entrada es la misma que la primera, y las señalará a la misma memoria). Se ahorraría un poco de memoria de pila, pero es tan insignificante que la sobrecarga no vale la pena. Nuevamente, el punto es que es fácil para el compilador optimizar cadenas literales.

Ahí lo tienen ... una explicación .equals() para == vs. .equals() y por qué parece aleatorio.

Answer 12

Si va a comparar cualquier valor asignado de la cadena, es decir, la cadena primitiva, tanto "==" como .equals funcionarán, pero para el nuevo objeto de cadena debería usar solo .equals, y aquí "==" no funcionará.

Ejemplo:

String a = "name";

String b = "name";

if(a == b) y (a.equals(b)) devolverá true.

Pero

String a = new String("a");

En este caso if(a == b) devolverá false

Así que es mejor usar el operador .equals ...

Answer 13

También funcionará si llama a intern() en la cadena antes de insertarlo en la matriz. Las cadenas internas son iguales a la referencia ( == ) si y solo si son iguales en valor ( equals() .

public static void main (String... aArguments) throws IOException {

String usuario = "Jorman";
String password = "14988611";

String strDatos="Jorman 14988611";
StringTokenizer tokens=new StringTokenizer(strDatos, " ");
int nDatos=tokens.countTokens();
String[] datos=new String[nDatos];
int i=0;

while(tokens.hasMoreTokens()) {
    String str=tokens.nextToken();
    datos[i]= str.intern();            
    i++;
}

//System.out.println (usuario);

if(datos[0]==usuario) {  
     System.out.println ("WORKING");    
}

Answer 14

Use Split en lugar de tokenizer, seguramente proporcionará u salida exacta para Eg:

string name="Harry";
string salary="25000";
string namsal="Harry 25000";
string[] s=namsal.split(" ");
for(int i=0;i<s.length;i++)
{
System.out.println(s[i]);
}
if(s[0].equals("Harry"))
{
System.out.println("Task Complete");
}

Después de esto estoy seguro de que obtendrás mejores resultados ...

Answer 15

Utilice la función string.equals(Object other) para comparar cadenas, no el operador == .

La función verifica el contenido real de la cadena, el operador == comprueba si las referencias a los objetos son iguales. Tenga en cuenta que las constantes de cadena suelen estar "internadas", de modo que dos constantes con el mismo valor pueden compararse con == , pero es mejor no confiar en eso.

if (usuario.equals(datos[0])) {
    ...
}

NB: la comparación se realiza en ''usuario'' porque se garantiza que no es nulo en su código, aunque aún debe verificar que realmente tenga algunos tokens en la matriz de datos contrario, obtendrá una matriz fuera de límites. excepción.

Answer 16

== operador == compara la referencia de un objeto en Java. Puedes usar el método de equals de cadena.

String s = "Test";
if(s.equals("Test"))
{
    System.out.println("Equal");
}

Answer 17

== pruebas de igualdad de referencia.

.equals() pruebas de igualdad de valores.

Por consiguiente, si realmente quiere probar si dos cadenas tienen el mismo valor, debe usar .equals() (excepto en algunas situaciones en las que puede garantizar que dos cadenas con el mismo valor serán representadas por el mismo objeto, por ejemplo: Interning de String ).

== es para probar si dos cadenas son el mismo Object .

// These two have the same value
new String("test").equals("test") ==> true 

// ... but they are not the same object
new String("test") == "test" ==> false 

// ... neither are these
new String("test") == new String("test") ==> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" ==> true 

// concatenation of string literals happens at compile time resulting in same objects
"test" == "te" + "st"  ==> true

// but .substring() is invoked at runtime, generating distinct objects
"test" == "!test".substring(1) ==> false

Es importante tener en cuenta que == es mucho más barato que equals() (una comparación de un solo puntero en lugar de un bucle), por lo tanto, en situaciones donde sea aplicable (es decir, puede garantizar que solo está tratando con cadenas internas). Presentar una mejora importante del rendimiento. Sin embargo, estas situaciones son raras.

Answer 18

a==b

Compara referencias, no valores. El uso de == con referencias a objetos generalmente se limita a lo siguiente:

1. Comparando para ver si una referencia es null .

2. Comparando dos valores de enumeración. Esto funciona porque solo hay un objeto para cada constante de enum .

3. Quieres saber si dos referencias son del mismo objeto.

"a".equals("b")

Compara los valores por la igualdad. Debido a que este método está definido en la clase Object , de la cual se derivan todas las demás clases, se define automáticamente para cada clase. Sin embargo, no realiza una comparación inteligente para la mayoría de las clases, a menos que la clase la anule. Se ha definido de manera significativa para la mayoría de las clases principales de Java. Si no está definido para una clase (usuario), se comporta igual que == .

Answer 19

equals() es un método de clase de Object que debe ser anulado por el programador. String clase de String anula para verificar si dos cadenas son iguales, es decir, en el contenido y no en la referencia.

== operador == comprueba si las referencias de ambos objetos son iguales.

Considerar los programas

String abc = "Awesome" ;
String xyz =  abc;

if(abc == xyz)
     System.out.println("Refers to same string");

Aquí el abc y xyz , ambos se refieren a la misma String "Awesome" . Por lo tanto, la expresión (abc == xyz) es true .

String abc = "Hello World";
String xyz = "Hello World";

if(abc == xyz)
    System.out.println("Refers to same string");
else
    System.out.println("Refers to different strings");

if(abc.equals(xyz))
     System.out.prinln("Contents of both strings are same");
else
     System.out.prinln("Contents of strings are different");

Aquí abc y xyz son dos cadenas diferentes con el mismo contenido "Hello World" . Por lo tanto, aquí la expresión (abc == xyz) es false donde as (abc.equals(xyz)) es true .

Espero que hayas entendido la diferencia entre == y <Object>.equals()

Gracias.

Answer 20

The == operator checks if the two references point to the same object or not.
.equals() checks for the actual string content (value).

Tenga en cuenta que el método .equals () pertenece a la clase Object (super clase de todas las clases). Debe anularlo según su requisito de clase, pero para String ya está implementado y verifica si dos cadenas tienen el mismo valor o no.

Case1)
String s1 = "";
String s2 = "";
s1 == s1;      // true
s1.equals(s2); // true
Reason: String literals created without null are stored in the string pool in the permgen area of the heap. So both s1 and s2 point to the same object in the pool.
Case2)
String s1 = new String("");
String s2 = new String("");
s1 == s2;      // false
s1.equals(s2); // true
Reason: If you create a String object using the `new` keyword a separate space is allocated to it on the heap.