¿La comparación de Java con == de dos cadenas es falsa?

Las partes de cadena son cadenas [6]:

 ["231", "CA-California", "Sacramento-155328", "aleee", "Empleado de servicio al cliente", "Alegra Keith.doc.txt"]

Pero cuando comparo parts[0] con "231" :

 "231" == parts[0] 

el resultado anterior es falso,

Estoy confundido, entonces ¿alguien podría decirme por qué?

El operador == compara las referencias de objeto, no el valor de las String .

Para comparar los valores de String s, use el método String.equals :

 "231".equals(parts[0]); 

Esto es cierto con cualquier otro objeto en Java: al comparar valores, siempre use el método equals lugar de usar el operador == .

El método equals es parte de Object y debe ser reemplazado por clases que se compararán de una forma u otra.

Si las cadenas no se internan, entonces == verifica la identidad de referencia. Utilizar:

  "231".equals(parts[0]); 

en lugar.

== en Java compara la dirección de los objetos (cadenas en este caso).

Lo que quiere es parts[0].equals("231")

Lo siguiente imprime “verdadero”;

 String s = "231"; if(s == "231") { System.out.println("true"); } else { System.out.println("false"); } 

Esto se debe a que las cadenas no son mutables y Java intentará y guardará tanto espacio como sea posible, por lo que apunta a la misma referencia de memoria.

Sin embargo, lo siguiente imprime “falso”:

 String s = new String("231"); if(s == "231") { System.out.println("true"); } else { System.out.println("false"); } 

new obligará a almacenar la cadena en una nueva ubicación de memoria.

Por cierto, SIEMPRE debe usar .equals() para comparar cadenas (para casos como este)

Use el método equals: parts [0] .equals (“231”). == operador compara referencias de objetos.

“==” compara referencias de objeto, en su caso “231” es un objeto diferente de partes [0].

Desea utilizar String.equals .

 parts[0].equals("231") 

La respuesta es muy simple: cuando compara cadenas a través de == operator, realmente compara si dos variables diferentes se refieren a un único objeto String. Y no es así, la cadena de la matriz y el “231” recién creado son diferentes objetos String con los mismos contenidos.

Lo correcto es usar la siguiente expresión: "231".equals(parts[0]) o "231".equalsIgnoreCase(parts[0]) . Esto le dará lo que necesita y devolverá verdadero si estos objetos String contienen los mismos valores.

Pensé que podría ser útil express la respuesta en un caso de prueba:

 public class String231Test extends TestCase { private String a; private String b; protected void setUp() throws Exception { a = "231"; StringBuffer sb = new StringBuffer(); sb.append("231"); b = sb.toString(); } public void testEquals() throws Exception { assertTrue(a.equals(b)); } public void testIdentity() throws Exception { assertFalse(a == b); } } 

También puede usar el método compareTo (String) :

 String str = "test"; if( str.compareTo("test") == 0) //the argument string is equal to str; else //the argument string is not equal to str; 

Use el método de igualdad para comparar objetos:

 String[] test = {"231", "CA-California", "Sacramento-155328", "aleee", "Customer Service Clerk", "Alegra Keith.doc.txt"}; System.out.println("231".equals(test[0])); 

La comparación ‘==’ compara referencias, no valores.

Aquí hay un buen ejemplo. El operador ‘==’ con una cadena puede ser realmente complicado en Java.

 class Foo { public static void main(String[] args) { String a = "hello"; String b = "hello"; String c = "h"; c = c + "ello"; String operator = null; if(a == b) { operator = " == "; } else { operator = " != "; } System.out.println(a + operator + b); if(a == c) { operator = " == "; } else { operator = " != "; } System.out.println(a + operator + c); if(a == "hello") { operator = " == "; } else { operator = " != "; } System.out.println(a + operator + "hello"); if(c == "hello") { operator = " == "; } else { operator = " != "; } System.out.println(c + operator + "hello"); } } 

Que producirá el siguiente resultado:

 hello == hello hello != hello hello == hello hello != hello 

Como muchos otros ya han explicado, intente comparar con el operador de igualdad, pero luego se basaría en Object.equals () en lugar de String.equals ().

Para que pueda hacer el trabajo llamando explícitamente a String.equals (), pero en lugar de escribir

 parts[0].equals("blahblah") 

Yo preferiría tal:

 "blahblah".equals(parts[0]) 

Ya que evita probar la posible nulidad de las partes [0] (pero tenga cuidado de que la variable de las partes en sí misma sea nula …)

Otra forma es usar String.intern ():

 if (parts[0].intern() == "blahblah") ... 

Consulte http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#intern () para obtener más información sobre eso.