manejo - ingresar nombre en java

Grupo de cadenas de Java y tipo de fundición

Question

Mi pregunta es con respecto a la forma en que Java maneja los literales de cadena. De las especificaciones de lenguaje de Java (JLS) se desprende claramente que los literales String están internados implícitamente; en otras palabras, los objetos que se crean en la parte del grupo de constante de cadena del montón, en contraste con los objetos basados ​​en el montón creados al llamar a una new String("whatever") .

Lo que no parece estar alineado con lo que dice el JLS es que al crear una nueva cadena usando concatenación de cadenas con un tipo de cadena constante fundida, que debe considerarse como una cadena constante según el JLS, aparentemente la JVM está creando un nuevo Cadena de objeto en lugar de internarlo implícitamente. Agradezco cualquier explicación sobre este comportamiento particular y si este es o no un comportamiento específico de la plataforma. Estoy corriendo con Mac OSX Snow Leopard.

public class Test
{
    public static void main(String args[])
    {
        /*
            Create a String object on the String constant pool
            using a String literal
        */
        String hello = "hello";
        final String lo = "lo"; // this will be created in the String pool as well
        /*
            Compare the hello variable to a String constant expression
            , that should cause the JVM to implicitly call String.intern()
        */
        System.out.println(hello == ("hel" + lo));// This should print true
        /*
            Here we need to create a String by casting an Object back
            into a String, this will be used later to create a constant
            expression to be compared with the hello variable
        */
        Object object = "lo";
        final String stringObject = (String) object;// as per the JLS, casted String types can be used to form constant expressions
        /*
            Compare with the hello variable
        */
        System.out.println(hello == "hel" + stringObject);// This should print true, but it doesn''t :(

    }
}

Answer 1

Casting to Object no está permitido en una expresión constante de tiempo de compilación. Los únicos moldes permitidos son String y primitives. JLS (Java SE 7 edition) sección 15.28:

> - Cambia a tipos y moldes primitivos para escribir String

(En realidad, hay una segunda razón: el object no es final por lo que no puede considerarse una variable constante . "Se llama una variable de tipo primitivo o tipo String , que es final e inicializada con una expresión constante en tiempo de compilación (§15.28). una variable constante. "- sección 4.12.4.)

Answer 2

Parece que hace referencia aquí a un objeto final String stringObject = (String) object; , esto ya no es una constante de "tiempo de compilación", sino una constante de "tiempo de ejecución". El primer ejemplo de aquí se le escapa con la parte:

String s = "lo";
String str7 = "Hel"+ s;  
String str8 = "He" + "llo"; 
System.out.println("str7 is computed at runtime.");     
System.out.println("str8 is created by using string constant expression.");    
System.out.println("    str7 == str8 is " + (str7 == str8));  
System.out.println("    str7.equals(str8) is " + str7.equals(str8));

La cadena str7 se calcula en tiempo de ejecución, porque hace referencia a otra cadena que no es literal, por lo que con esa lógica supongo que a pesar de que stringObject , sigue haciendo referencia a un objeto, por lo que no puede computarse en tiempo de compilación.

Y de la especificación de java lang aquí , dice:

"El operador de concatenación de cadenas + (§15.18.1) crea implícitamente un nuevo objeto String cuando el resultado no es una expresión constante en tiempo de compilación (§15.28)".

No puedo encontrar ningún ejemplo donde se pueda usar un elenco, excepto por este terrible y terrible ejemplo:

System.out.println(hello == "hel" + ( String ) "lo");

Que casi no tiene ningún uso lógico, pero tal vez la parte sobre un molde de cuerda se incluyó debido al caso anterior.