Java "igual" y "==" similitudes
Primero, hablemos brevemente de "igual" y "=="
== La operación compara si los valores de las dos variables son iguales para el tipo de datos básicos.
Para las variables de referencia, significa si las direcciones almacenadas en el montón son las mismas,
¿El contenido en la pila es el mismo?
Si las dos variables representadas por la operación igual son referencias al mismo objeto,
Es decir, si el contenido en el montón es el mismo.
En resumen, == compara las direcciones de 2 objetos, mientras que iguales compara el contenido de 2 objetos.
Permítanme presentar brevemente la clase de cadena
La clase de cadena también se llama secuencia de caracteres inmutable
La cadena utiliza el valor de char final privado [] para realizar el almacenamiento de cadenas. Es decir, después de que se crea el objeto de cadena, el contenido de cadena almacenado en este objeto no puede modificarse. La clase de cadena tiene un método de creación especial, que es usar "" citas dobles para crearlo. Por ejemplo, la nueva cadena ("123") en realidad crea 2 objetos de cadena, uno es creado por "123" a "" citas dobles, y la otra es creada por NUEVO. Sin embargo, los períodos que crean son diferentes, uno es el período de compilación y el otro es el período de ejecución. Java sobrecarga el operador + para el tipo de cadena, y puede usar directamente + para concatenar dos cadenas. Llamar al método Intern () de la clase de cadena durante el tiempo de ejecución puede agregar dinámicamente objetos al grupo de cadenas.
Diferenciar entre dos métodos para crear objetos de cadena "" y new ()
La cadena es un datos de embalaje especiales. Se puede usar:
Cadena str1 = nueva cadena ("123"); String str2 = "123";Crear dos formas
El primero es usar nuevo () para crear un nuevo objeto, que se almacenará en el montón. Se crea un nuevo objeto cada vez que se llama. (En realidad son dos, como se mencionó anteriormente, pero después de la existencia de "123" en el grupo constante, el nuevo "123" ya no se creará en el grupo constante)
El segundo tipo es crear primero una variable STR al objeto de la clase de cadena en la pila, y luego usar una referencia simbólica para averiguar si hay "ABC" en el grupo constante de cadena. Si no, almacene "ABC" en la piscina constante de cadena y deje que STR apunte a "ABC". Si ya hay "ABC", entonces STR apunte directamente a "ABC".
Deberíamos prestar atención en este momento
Por un lado, el primer método de escritura es beneficioso y ahorra espacio de memoria. Al mismo tiempo, puede mejorar la velocidad de ejecución del programa hasta cierto punto, porque el JVM decidirá automáticamente si es necesario crear un nuevo objeto basado en la situación real de los datos en la pila. Para el código de cadena str = new String ("123");, se crean nuevos objetos en el montón independientemente de si los valores de cadena son iguales o no, si es necesario crear nuevos objetos, aumentando así la carga en el programa. Por otro lado, cuando definimos una clase usando un formato como String Str = "123";, siempre damos por sentado que creamos un objeto STR de la clase de cadena.
¡El objeto puede no haber sido creado! Y tal vez solo apunte a un objeto que se ha creado anteriormente. Solo a través del método nuevo () podemos asegurarnos de que se cree un nuevo objeto cada vez.
Consulte el siguiente ejemplo
TestString de paquetes; public class testString {public static void main (string [] args) {String a = "123"; Cadena b = "123"; System.out.println (a == b); System.out.println (a.equals (b)); System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- And El contenido de los dos objetos referenciados en el montón es el mismo, por lo que A.Equals (b) es verdadero */ String C = New String ("1234"); System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- But c is lo mismo que D Heap, por lo que C.Equals (d) es verdadero */ String e = "A1"; Cadena F = "A" +1; System.out.println (e == f); System.out.println (E.Equals (f)); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- * Sí, Java en sí tiene una sobrecarga de operadores, pero no puede usar la sobrecarga de operadores que se define a sí misma. "H"; System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!