String.equals versus == [duplicado]
Este código separa una cadena en tokens y los almacena en una matriz de cadenas, y luego compara una variable con el primer inicio... ¿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");
}
}
Utilice la string.equals(Object other)función para comparar cadenas, no el ==operador.
La función verifica el contenido real de la cadena, el ==operador verifica si las referencias a los objetos son iguales. Tenga en cuenta que las constantes de cadena generalmente están "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 datosmatriz, de lo contrario obtendrá una excepción de matriz fuera de límites. .
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 las calles Madison o Burke, esto es lo único que pueden decir:
Usando solo la residencia, es difícil confirmar que se trata del mismo Jorman. Dado que son 2 direcciones diferentes, es natural suponer que son 2 personas diferentes.
Así ==se comporta el operador. Entonces dirá que datos[0]==usuarioes falso, porque solo compara las direcciones .
Un investigador al rescate
¿Y si enviamos un investigador? Sabemos que es el mismo Jorman, pero tenemos que demostrarlo. Nuestro detective observará detenidamente todos los aspectos físicos. Con una investigación exhaustiva, el agente podrá concluir si se trata de la misma persona o no. Veamos cómo sucede en términos de Java.
equals()Aquí está el código fuente del método de String :
Compara las cadenas carácter por carácter, para llegar a la conclusión de que efectivamente son iguales.
Así es como equalsse comporta el método String. Entonces datos[0].equals(usuario)devolverá verdadero, porque realiza una comparación lógica .
Es bueno notar que en algunos casos el uso del operador "==" puede conducir al resultado esperado, debido a la forma en que Java maneja las cadenas (los literales de cadena se internan (ver String.intern()) durante la compilación), por lo que cuando escribe, por ejemplo, "hello world"en dos clases y compare esas cadenas con "==" y podría obtener el resultado: verdadero, que se espera según la especificación ; cuando se comparan las mismas cadenas (si tienen el mismo valor) cuando la primera es una cadena literal (es decir, definida mediante "i am string literal") y la segunda se construye durante el tiempo de ejecución, es decir. con la palabra clave "nueva" como new String("i am string literal"), el ==operador (igualdad) devuelve falso, porque ambas son instancias diferentes de la Stringclase.
La única forma correcta es usar .equals()-> datos[0].equals(usuario). ==dice sólo 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 la pasantía (String.intern) es un efecto secundario de la optimización de JVM. Aunque ciertamente ahorra recursos de memoria (que es lo que quise decir con "optimización"), es principalmente una característica del lenguaje.
equals()La función es un método de Objectclase que el programador debe anular. StringLa clase lo anula para comprobar si dos cadenas son iguales, es decir, en contenido y no en referencia.
==El operador comprueba si las referencias de ambos objetos son las mismas.
Considere los programas
String abc = "Awesome" ;
String xyz = abc;
if(abc == xyz)
System.out.println("Refers to same string");
Aquí el abcy xyzambos se refieren a lo mismo String "Awesome". Por 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í abcy xyzhay dos cadenas diferentes con el mismo contenido "Hello World". Por lo tanto aquí la expresión (abc == xyz)es falsedonde como (abc.equals(xyz))está true.
Espero que hayas entendido la diferencia entre ==y<Object>.equals()
Gracias.
