java - Relacionado con el internado de cuerdas

string string-interning

Question

public static void main(String[] args) {
String a = new String("lo").intern();
final String d = a.intern();
String b = "lo";
final String e = "lo";
String c = "Hello";
System.out.println(b==a);//true
System.out.println(d==a);//true
System.out.println(e==a);//true
System.out.println(c=="Hel"+a); //why is this false? when e==a is true
System.out.println(c=="Hel"+d); //why is this false?
System.out.println(c=="Hel"+b); //why is this false?
System.out.println(c=="Hel"+e); //this is true
}

Esto resulta en

true
true
true
false
false
false
true

La expresión e==a es verdadera implica la misma referencia. Entonces, ¿por qué la última expresión es verdadera pero la cuarta es la última, es decir, c== "Hel"+a es falsa?

Answer 1

Aunque esté utilizando el método intern() , debe recordar que == compara por referencia y no por valor.

Así que en los casos de

System.out.println(c=="Hel"+a);
System.out.println(c=="Hel"+d);
System.out.println(c=="Hel"+b); 

"Hel" + a o "Hel" + d o "Hel" + b tendrá una nueva referencia en la memoria que no es igual a la de c .

en el caso final, ya que el valor de la cadena es final, la evaluación se realiza en tiempo de compilación en lugar de tiempo de ejecución como optimización, ya que nunca cambiará. Además, si está pensando cuando define una cadena literal, Java los coloca internamente.

Answer 2

La expresion

"Hel" + a

No es una constante de tiempo de compilación. En realidad, se compila a:

new StringBuilder().append("Hel").append(a).toString()

(o similar) que crea un nuevo objeto String en tiempo de ejecución.

Sin embargo, debido a que e es final, el compilador puede determinar que la concatenación de "Hel" y el valor de e es un valor constante, y así lo internan.

Answer 3

todas estas cadenas se calculan en tiempo de ejecución, es por eso que son diferentes

System.out.println(c=="Hel"+a); //why is this false? when e==a is true
System.out.println(c=="Hel"+d); //why is this false?
System.out.println(c=="Hel"+b); //why is this false?

este calculado durante el tiempo de compilación, porque e es final:

System.out.println(c=="Hel"+e); //this is true

Si cambia el código a esto:

 System.out.println(c==("Hel"+a).intern()); //why is this false? when e==a is true
System.out.println(c==("Hel"+d).intern()); //why is this false?
System.out.println(c==("Hel"+b).intern()); //why is this false?

todos ellos producirán verdad

Answer 4

El compilador Java ( javac ) traduce su código en Java a un código de bytes que ejecuta la JVM . También hace algunas optimizaciones para ti. Puede verificar el código de byte generado usando la utilidad javap con el parámetro -c

Concatenación con cuerda final

c==a es verdadero porque c es final Aquí está el código de byte para este fragmento (solo la última comparación):

public static void main(java.lang.String[]);
Code:
0: ldc #2; //String Hello
2: astore_2
3: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;
6: aload_2
7: ldc #2; //String Hello
9: if_acmpne 16
12: iconst_1
13: goto 17
16: iconst_0
17: invokevirtual #4; //Method java/io/PrintStream.println:(Z)V
20: return
}

Como puedes ver, el compilador java ha fusionado el "Hel" con "lo" y solo compara dos cadenas de caracteres "Hola". Java interns cadena literales de forma predeterminada - es por eso que devuelve true

Concatenación con cuerda no final

Si está concatenando el literal de cadena con una variable de cadena no final , el código de byte será diferente:

public static void main(java.lang.String[]);
Code:
0: ldc #2; //String lo
2: astore_1
3: ldc #3; //String Hello
5: astore_2
6: getstatic #4; //Field java/lang/System.out:Ljava/io/PrintStream;
9: aload_2
10: new #5; //class java/lang/StringBuilder
13: dup
14: invokespecial #6; //Method java/lang/StringBuilder."<init>":()V
17: ldc #7; //String Hel
19: invokevirtual #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: aload_1
23: invokevirtual #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
26: invokevirtual #9; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
29: if_acmpne 36
32: iconst_1
33: goto 37
36: iconst_0
37: invokevirtual #10; //Method java/io/PrintStream.println:(Z)V
40: return
}

Aquí estamos comparando el resultado de java/lang/StringBuilder.toString:()Ljava/lang/String; Método que obviamente devuelve otro objeto: es igual a "Hola" por valor pero no por referencia

Puede encontrar más detalles sobre la comparación de cadenas en esta pregunta de